RTEMS 4.11
Annotated Report
Sun Mar 20 21:54:38 2011

a0006b64 <CPU_usage_Per_thread_handler>: static void CPU_usage_Per_thread_handler( Thread_Control *the_thread ) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used );
a0006b64:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006b68:	e5803084 	str	r3, [r0, #132]	; 0x84                         <== NOT EXECUTED
a0006b6c:	e5803088 	str	r3, [r0, #136]	; 0x88                         <== NOT EXECUTED
  #else                                                               
    the_thread->cpu_time_used = 0;                                    
  #endif                                                              
}                                                                     
a0006b70:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000d83c <IMFS_Set_handlers>: { IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; switch( node->type ) {
a000d83c:	e5903000 	ldr	r3, [r0]                                      
)                                                                     
{                                                                     
  IMFS_jnode_t    *node = loc->node_access;                           
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
a000d840:	e5902010 	ldr	r2, [r0, #16]                                 
  switch( node->type ) {                                              
a000d844:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
)                                                                     
{                                                                     
  IMFS_jnode_t    *node = loc->node_access;                           
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
a000d848:	e5922034 	ldr	r2, [r2, #52]	; 0x34                          
  switch( node->type ) {                                              
a000d84c:	e2433001 	sub	r3, r3, #1                                    
a000d850:	e3530006 	cmp	r3, #6                                        
a000d854:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        
a000d858:	ea000008 	b	a000d880 <IMFS_Set_handlers+0x44>               <== NOT EXECUTED
a000d85c:	a000d8a8 	.word	0xa000d8a8                                  <== NOT EXECUTED
a000d860:	a000d8b8 	.word	0xa000d8b8                                  <== NOT EXECUTED
a000d864:	a000d898 	.word	0xa000d898                                  <== NOT EXECUTED
a000d868:	a000d898 	.word	0xa000d898                                  <== NOT EXECUTED
a000d86c:	a000d888 	.word	0xa000d888                                  <== NOT EXECUTED
a000d870:	a000d888 	.word	0xa000d888                                  <== NOT EXECUTED
a000d874:	a000d878 	.word	0xa000d878                                  <== NOT EXECUTED
      break;                                                          
    case IMFS_MEMORY_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
      break;                                                          
    case IMFS_FIFO:                                                   
      loc->handlers = fs_info->fifo_handlers;                         
a000d878:	e5923010 	ldr	r3, [r2, #16]                                 <== NOT EXECUTED
a000d87c:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000d880:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000d884:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
      break;                                                          
    case IMFS_LINEAR_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
      break;                                                          
    case IMFS_MEMORY_FILE:                                            
      loc->handlers = fs_info->memfile_handlers;                      
a000d888:	e5923008 	ldr	r3, [r2, #8]                                  <== NOT EXECUTED
a000d88c:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
      loc->handlers = fs_info->fifo_handlers;                         
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000d890:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000d894:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    case IMFS_DEVICE:                                                 
      loc->handlers = &IMFS_device_handlers;                          
      break;                                                          
    case IMFS_SYM_LINK:                                               
    case IMFS_HARD_LINK:                                              
      loc->handlers = &IMFS_link_handlers;                            
a000d898:	e59f3028 	ldr	r3, [pc, #40]	; a000d8c8 <IMFS_Set_handlers+0x8c><== NOT EXECUTED
a000d89c:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
      loc->handlers = fs_info->fifo_handlers;                         
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000d8a0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000d8a4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  IMFS_fs_info_t  *fs_info;                                           
                                                                      
  fs_info = loc->mt_entry->fs_info;                                   
  switch( node->type ) {                                              
    case IMFS_DIRECTORY:                                              
      loc->handlers = fs_info->directory_handlers;                    
a000d8a8:	e592300c 	ldr	r3, [r2, #12]                                 
a000d8ac:	e5803008 	str	r3, [r0, #8]                                  
      loc->handlers = fs_info->fifo_handlers;                         
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000d8b0:	e3a00000 	mov	r0, #0                                        
a000d8b4:	e12fff1e 	bx	lr                                             
  switch( node->type ) {                                              
    case IMFS_DIRECTORY:                                              
      loc->handlers = fs_info->directory_handlers;                    
      break;                                                          
    case IMFS_DEVICE:                                                 
      loc->handlers = &IMFS_device_handlers;                          
a000d8b8:	e59f300c 	ldr	r3, [pc, #12]	; a000d8cc <IMFS_Set_handlers+0x90><== NOT EXECUTED
a000d8bc:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
      loc->handlers = fs_info->fifo_handlers;                         
      break;                                                          
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000d8c0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000d8c4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000e238 <IMFS_check_node_remove>: void IMFS_check_node_remove( IMFS_jnode_t *jnode ) {
a000e238:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000e23c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) {  
a000e240:	eb000151 	bl	a000e78c <rtems_libio_is_file_open>            <== NOT EXECUTED
a000e244:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e248:	1a00000f 	bne	a000e28c <IMFS_check_node_remove+0x54>        <== NOT EXECUTED
a000e24c:	e1d433b4 	ldrh	r3, [r4, #52]	; 0x34                         <== NOT EXECUTED
a000e250:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000e254:	1a00000c 	bne	a000e28c <IMFS_check_node_remove+0x54>        <== NOT EXECUTED
    if ( rtems_filesystem_current.node_access == jnode )              
a000e258:	e59f2048 	ldr	r2, [pc, #72]	; a000e2a8 <IMFS_check_node_remove+0x70><== NOT EXECUTED
a000e25c:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
a000e260:	e5921004 	ldr	r1, [r2, #4]                                  <== NOT EXECUTED
a000e264:	e1510004 	cmp	r1, r4                                        <== NOT EXECUTED
       rtems_filesystem_current.node_access = NULL;                   
a000e268:	05823004 	streq	r3, [r2, #4]                                <== NOT EXECUTED
                                                                      
    switch ( jnode->type ) {                                          
a000e26c:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000e270:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a000e274:	0a000008 	beq	a000e29c <IMFS_check_node_remove+0x64>        <== NOT EXECUTED
a000e278:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
a000e27c:	0a000003 	beq	a000e290 <IMFS_check_node_remove+0x58>        <== NOT EXECUTED
        break;                                                        
      default:                                                        
        break;                                                        
    }                                                                 
                                                                      
    free( jnode );                                                    
a000e280:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  }                                                                   
}                                                                     
a000e284:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
        break;                                                        
      default:                                                        
        break;                                                        
    }                                                                 
                                                                      
    free( jnode );                                                    
a000e288:	eaffe039 	b	a0006374 <free>                                 <== NOT EXECUTED
a000e28c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
    if ( rtems_filesystem_current.node_access == jnode )              
       rtems_filesystem_current.node_access = NULL;                   
                                                                      
    switch ( jnode->type ) {                                          
      case IMFS_MEMORY_FILE:                                          
        IMFS_memfile_remove( jnode );                                 
a000e290:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e294:	eb000734 	bl	a000ff6c <IMFS_memfile_remove>                 <== NOT EXECUTED
        break;                                                        
a000e298:	eafffff8 	b	a000e280 <IMFS_check_node_remove+0x48>          <== NOT EXECUTED
      case IMFS_SYM_LINK:                                             
        free( jnode->info.sym_link.name );                            
a000e29c:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000e2a0:	ebffe033 	bl	a0006374 <free>                                <== NOT EXECUTED
        break;                                                        
a000e2a4:	eafffff5 	b	a000e280 <IMFS_check_node_remove+0x48>          <== NOT EXECUTED
                                                                      

a000d5fc <IMFS_chown>: int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) {
a000d5fc:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t  *jnode;                                               
#if defined(RTEMS_POSIX_API)                                          
  uid_t          st_uid;                                              
#endif                                                                
                                                                      
  jnode = (IMFS_jnode_t *) pathloc->node_access;                      
a000d600:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
int IMFS_chown(                                                       
  rtems_filesystem_location_info_t  *pathloc,       /* IN */          
  uid_t                              owner,         /* IN */          
  gid_t                              group          /* IN */          
)                                                                     
{                                                                     
a000d604:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
  jnode->st_gid = group;                                              
                                                                      
  IMFS_update_ctime( jnode );                                         
a000d608:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
    rtems_set_errno_and_return_minus_one( EPERM );                    
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
a000d60c:	e1c413bc 	strh	r1, [r4, #60]	; 0x3c                         <== NOT EXECUTED
  jnode->st_gid = group;                                              
a000d610:	e1c423be 	strh	r2, [r4, #62]	; 0x3e                         <== NOT EXECUTED
                                                                      
  IMFS_update_ctime( jnode );                                         
a000d614:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000d618:	ebffe38a 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a000d61c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000d620:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
  jnode->st_gid = group;                                              
                                                                      
  IMFS_update_ctime( jnode );                                         
a000d624:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000d628:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000d62c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000d6ac <IMFS_create_node>: IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) {
a000d6ac:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  IMFS_fs_info_t      *fs_info;                                       
                                                                      
  /*                                                                  
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
a000d6b0:	e3500000 	cmp	r0, #0                                        
  IMFS_jnode_types_t                type,                             
  const char                       *name,                             
  mode_t                            mode,                             
  const IMFS_types_union           *info                              
)                                                                     
{                                                                     
a000d6b4:	e1a04001 	mov	r4, r1                                        
a000d6b8:	e59d7018 	ldr	r7, [sp, #24]                                 
                                                                      
  /*                                                                  
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
    return NULL;                                                      
a000d6bc:	01a08000 	moveq	r8, r0                                      
  IMFS_fs_info_t      *fs_info;                                       
                                                                      
  /*                                                                  
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
a000d6c0:	0a00002b 	beq	a000d774 <IMFS_create_node+0xc8>              
    return NULL;                                                      
                                                                      
  parent = parent_loc->node_access;                                   
  fs_info = parent_loc->mt_entry->fs_info;                            
a000d6c4:	e5901010 	ldr	r1, [r0, #16]                                 
                                                                      
  /*                                                                  
   *  Reject creation of FIFOs if support is disabled.                
   */                                                                 
  if ( type == IMFS_FIFO &&                                           
a000d6c8:	e3540007 	cmp	r4, #7                                        
   *  MUST have a parent node to call this routine.                   
   */                                                                 
  if ( parent_loc == NULL )                                           
    return NULL;                                                      
                                                                      
  parent = parent_loc->node_access;                                   
a000d6cc:	e5906000 	ldr	r6, [r0]                                      
  fs_info = parent_loc->mt_entry->fs_info;                            
a000d6d0:	e5915034 	ldr	r5, [r1, #52]	; 0x34                          
                                                                      
  /*                                                                  
   *  Reject creation of FIFOs if support is disabled.                
   */                                                                 
  if ( type == IMFS_FIFO &&                                           
a000d6d4:	0a000028 	beq	a000d77c <IMFS_create_node+0xd0>              
    return NULL;                                                      
                                                                      
  /*                                                                  
   *  Allocate filesystem node and fill in basic information          
   */                                                                 
  node  = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
a000d6d8:	e1a01002 	mov	r1, r2                                        
a000d6dc:	e59f2110 	ldr	r2, [pc, #272]	; a000d7f4 <IMFS_create_node+0x148>
a000d6e0:	e1a00004 	mov	r0, r4                                        
a000d6e4:	e5922000 	ldr	r2, [r2]                                      
a000d6e8:	e592202c 	ldr	r2, [r2, #44]	; 0x2c                          
a000d6ec:	e1c32002 	bic	r2, r3, r2                                    
a000d6f0:	ebffffce 	bl	a000d630 <IMFS_allocate_node>                  
  if ( !node )                                                        
a000d6f4:	e2508000 	subs	r8, r0, #0                                   
a000d6f8:	0a00001d 	beq	a000d774 <IMFS_create_node+0xc8>              
    return NULL;                                                      
                                                                      
  /*                                                                  
   *  Set the type specific information                               
   */                                                                 
  if ( type == IMFS_DIRECTORY ) {                                     
a000d6fc:	e3540001 	cmp	r4, #1                                        
a000d700:	0a00000d 	beq	a000d73c <IMFS_create_node+0x90>              
    rtems_chain_initialize_empty(&node->info.directory.Entries);      
  } else if ( type == IMFS_HARD_LINK ) {                              
a000d704:	e3540003 	cmp	r4, #3                                        
a000d708:	0a000026 	beq	a000d7a8 <IMFS_create_node+0xfc>              
    node->info.hard_link.link_node = info->hard_link.link_node;       
  } else if ( type == IMFS_SYM_LINK ) {                               
a000d70c:	e3540004 	cmp	r4, #4                                        
a000d710:	0a000024 	beq	a000d7a8 <IMFS_create_node+0xfc>              
    node->info.sym_link.name = info->sym_link.name;                   
  } else if ( type == IMFS_DEVICE ) {                                 
a000d714:	e3540002 	cmp	r4, #2                                        
a000d718:	0a00001e 	beq	a000d798 <IMFS_create_node+0xec>              
    node->info.device.major = info->device.major;                     
    node->info.device.minor = info->device.minor;                     
  } else if ( type == IMFS_LINEAR_FILE ) {                            
a000d71c:	e3540006 	cmp	r4, #6                                        <== NOT EXECUTED
a000d720:	0a000023 	beq	a000d7b4 <IMFS_create_node+0x108>             <== NOT EXECUTED
    node->info.linearfile.size      = 0;                              
    node->info.linearfile.direct    = 0;                              
  } else if ( type == IMFS_MEMORY_FILE ) {                            
a000d724:	e3540005 	cmp	r4, #5                                        <== NOT EXECUTED
a000d728:	0a000028 	beq	a000d7d0 <IMFS_create_node+0x124>             <== NOT EXECUTED
      node->info.file.size            = 0;                            
      node->info.file.indirect        = 0;                            
      node->info.file.doubly_indirect = 0;                            
      node->info.file.triply_indirect = 0;                            
  } else if ( type == IMFS_FIFO ) {                                   
a000d72c:	e3540007 	cmp	r4, #7                                        <== NOT EXECUTED
    node->info.fifo.pipe = NULL;                                      
a000d730:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a000d734:	05883050 	streq	r3, [r8, #80]	; 0x50                        <== NOT EXECUTED
a000d738:	ea000005 	b	a000d754 <IMFS_create_node+0xa8>                <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000d73c:	e2882054 	add	r2, r8, #84	; 0x54                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
a000d740:	e2883050 	add	r3, r8, #80	; 0x50                            
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a000d744:	e5882050 	str	r2, [r8, #80]	; 0x50                          
  head->previous = NULL;                                              
a000d748:	e3a02000 	mov	r2, #0                                        
a000d74c:	e5882054 	str	r2, [r8, #84]	; 0x54                          
  tail->previous = head;                                              
a000d750:	e5883058 	str	r3, [r8, #88]	; 0x58                          
                                                                      
  /*                                                                  
   *  This node MUST have a parent, so put it in that directory list. 
   */                                                                 
  node->Parent = parent;                                              
  node->st_ino = ++fs_info->ino_count;                                
a000d754:	e5953004 	ldr	r3, [r5, #4]                                  
a000d758:	e2860050 	add	r0, r6, #80	; 0x50                            
  }                                                                   
                                                                      
  /*                                                                  
   *  This node MUST have a parent, so put it in that directory list. 
   */                                                                 
  node->Parent = parent;                                              
a000d75c:	e5886008 	str	r6, [r8, #8]                                  
  node->st_ino = ++fs_info->ino_count;                                
a000d760:	e2833001 	add	r3, r3, #1                                    
a000d764:	e5853004 	str	r3, [r5, #4]                                  
a000d768:	e1a01008 	mov	r1, r8                                        
a000d76c:	e5883038 	str	r3, [r8, #56]	; 0x38                          
a000d770:	ebfff31d 	bl	a000a3ec <_Chain_Append>                       
                                                                      
  rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 
                                                                      
  return node;                                                        
}                                                                     
a000d774:	e1a00008 	mov	r0, r8                                        
a000d778:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
  fs_info = parent_loc->mt_entry->fs_info;                            
                                                                      
  /*                                                                  
   *  Reject creation of FIFOs if support is disabled.                
   */                                                                 
  if ( type == IMFS_FIFO &&                                           
a000d77c:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
a000d780:	e59f1070 	ldr	r1, [pc, #112]	; a000d7f8 <IMFS_create_node+0x14c><== NOT EXECUTED
a000d784:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
       fs_info->fifo_handlers == &rtems_filesystem_handlers_default ) 
    return NULL;                                                      
a000d788:	03a08000 	moveq	r8, #0                                      <== NOT EXECUTED
  fs_info = parent_loc->mt_entry->fs_info;                            
                                                                      
  /*                                                                  
   *  Reject creation of FIFOs if support is disabled.                
   */                                                                 
  if ( type == IMFS_FIFO &&                                           
a000d78c:	1affffd1 	bne	a000d6d8 <IMFS_create_node+0x2c>              <== NOT EXECUTED
  node->st_ino = ++fs_info->ino_count;                                
                                                                      
  rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 
                                                                      
  return node;                                                        
}                                                                     
a000d790:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000d794:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  } else if ( type == IMFS_HARD_LINK ) {                              
    node->info.hard_link.link_node = info->hard_link.link_node;       
  } else if ( type == IMFS_SYM_LINK ) {                               
    node->info.sym_link.name = info->sym_link.name;                   
  } else if ( type == IMFS_DEVICE ) {                                 
    node->info.device.major = info->device.major;                     
a000d798:	e897000c 	ldm	r7, {r2, r3}                                  
a000d79c:	e5882050 	str	r2, [r8, #80]	; 0x50                          
    node->info.device.minor = info->device.minor;                     
a000d7a0:	e5883054 	str	r3, [r8, #84]	; 0x54                          
a000d7a4:	eaffffea 	b	a000d754 <IMFS_create_node+0xa8>                
  if ( type == IMFS_DIRECTORY ) {                                     
    rtems_chain_initialize_empty(&node->info.directory.Entries);      
  } else if ( type == IMFS_HARD_LINK ) {                              
    node->info.hard_link.link_node = info->hard_link.link_node;       
  } else if ( type == IMFS_SYM_LINK ) {                               
    node->info.sym_link.name = info->sym_link.name;                   
a000d7a8:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
a000d7ac:	e5883050 	str	r3, [r8, #80]	; 0x50                          <== NOT EXECUTED
a000d7b0:	eaffffe7 	b	a000d754 <IMFS_create_node+0xa8>                <== NOT EXECUTED
  } else if ( type == IMFS_DEVICE ) {                                 
    node->info.device.major = info->device.major;                     
    node->info.device.minor = info->device.minor;                     
  } else if ( type == IMFS_LINEAR_FILE ) {                            
    node->info.linearfile.size      = 0;                              
a000d7b4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000d7b8:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a000d7bc:	e5883050 	str	r3, [r8, #80]	; 0x50                          <== NOT EXECUTED
a000d7c0:	e5884054 	str	r4, [r8, #84]	; 0x54                          <== NOT EXECUTED
    node->info.linearfile.direct    = 0;                              
a000d7c4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000d7c8:	e5883058 	str	r3, [r8, #88]	; 0x58                          <== NOT EXECUTED
a000d7cc:	eaffffe0 	b	a000d754 <IMFS_create_node+0xa8>                <== NOT EXECUTED
  } else if ( type == IMFS_MEMORY_FILE ) {                            
      node->info.file.size            = 0;                            
      node->info.file.indirect        = 0;                            
a000d7d0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    node->info.device.minor = info->device.minor;                     
  } else if ( type == IMFS_LINEAR_FILE ) {                            
    node->info.linearfile.size      = 0;                              
    node->info.linearfile.direct    = 0;                              
  } else if ( type == IMFS_MEMORY_FILE ) {                            
      node->info.file.size            = 0;                            
a000d7d4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000d7d8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000d7dc:	e5881050 	str	r1, [r8, #80]	; 0x50                          <== NOT EXECUTED
a000d7e0:	e5882054 	str	r2, [r8, #84]	; 0x54                          <== NOT EXECUTED
      node->info.file.indirect        = 0;                            
a000d7e4:	e5883058 	str	r3, [r8, #88]	; 0x58                          <== NOT EXECUTED
      node->info.file.doubly_indirect = 0;                            
a000d7e8:	e588305c 	str	r3, [r8, #92]	; 0x5c                          <== NOT EXECUTED
      node->info.file.triply_indirect = 0;                            
a000d7ec:	e5883060 	str	r3, [r8, #96]	; 0x60                          <== NOT EXECUTED
a000d7f0:	eaffffd7 	b	a000d754 <IMFS_create_node+0xa8>                <== NOT EXECUTED
                                                                      

a000e1ec <IMFS_create_orphan>: #include <rtems/libio_.h> #include "imfs.h" void IMFS_create_orphan( IMFS_jnode_t *jnode ) {
a000e1ec:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if ( jnode->Parent != NULL ) {                                      
a000e1f0:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
#include <rtems/libio_.h>                                             
                                                                      
#include "imfs.h"                                                     
                                                                      
void IMFS_create_orphan( IMFS_jnode_t *jnode )                        
{                                                                     
a000e1f4:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a000e1f8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if ( jnode->Parent != NULL ) {                                      
a000e1fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000e200:	0a000002 	beq	a000e210 <IMFS_create_orphan+0x24>            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
a000e204:	ebfff083 	bl	a000a418 <_Chain_Extract>                      <== NOT EXECUTED
    rtems_chain_extract( &jnode->Node );                              
    jnode->Parent = NULL;                                             
a000e208:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000e20c:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  --jnode->st_nlink;                                                  
a000e210:	e1d433b4 	ldrh	r3, [r4, #52]	; 0x34                         <== NOT EXECUTED
                                                                      
  IMFS_update_ctime( jnode );                                         
a000e214:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000e218:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  if ( jnode->Parent != NULL ) {                                      
    rtems_chain_extract( &jnode->Node );                              
    jnode->Parent = NULL;                                             
  }                                                                   
                                                                      
  --jnode->st_nlink;                                                  
a000e21c:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000e220:	e1c433b4 	strh	r3, [r4, #52]	; 0x34                         <== NOT EXECUTED
                                                                      
  IMFS_update_ctime( jnode );                                         
a000e224:	ebffe087 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a000e228:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000e22c:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
}                                                                     
a000e230:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000e234:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0008894 <IMFS_dump>: * NOTE: Assuming the "/" directory is bad. * Not checking that the starting directory is in an IMFS is bad. */ void IMFS_dump( void ) {
a0008894:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  fprintf(stdout, "*************** Dump of Entire IMFS ***************\n" );
a0008898:	e59f405c 	ldr	r4, [pc, #92]	; a00088fc <IMFS_dump+0x68>     <== NOT EXECUTED
a000889c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00088a0:	e3a02034 	mov	r2, #52	; 0x34                                <== NOT EXECUTED
a00088a4:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00088a8:	e59f0050 	ldr	r0, [pc, #80]	; a0008900 <IMFS_dump+0x6c>     <== NOT EXECUTED
a00088ac:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a00088b0:	eb00379c 	bl	a0016728 <fwrite>                              <== NOT EXECUTED
  fprintf(stdout, "/\n" );                                            
a00088b4:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00088b8:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a00088bc:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00088c0:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a00088c4:	e59f0038 	ldr	r0, [pc, #56]	; a0008904 <IMFS_dump+0x70>     <== NOT EXECUTED
a00088c8:	eb003796 	bl	a0016728 <fwrite>                              <== NOT EXECUTED
  IMFS_dump_directory( rtems_filesystem_root.node_access, 0 );        
a00088cc:	e59f3034 	ldr	r3, [pc, #52]	; a0008908 <IMFS_dump+0x74>     <== NOT EXECUTED
a00088d0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00088d4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00088d8:	e5930018 	ldr	r0, [r3, #24]                                 <== NOT EXECUTED
a00088dc:	ebffffc9 	bl	a0008808 <IMFS_dump_directory>                 <== NOT EXECUTED
  fprintf(stdout, "***************      End of Dump       ***************\n" );
a00088e0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00088e4:	e59f0020 	ldr	r0, [pc, #32]	; a000890c <IMFS_dump+0x78>     <== NOT EXECUTED
a00088e8:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00088ec:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a00088f0:	e3a02037 	mov	r2, #55	; 0x37                                <== NOT EXECUTED
}                                                                     
a00088f4:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
void IMFS_dump( void )                                                
{                                                                     
  fprintf(stdout, "*************** Dump of Entire IMFS ***************\n" );
  fprintf(stdout, "/\n" );                                            
  IMFS_dump_directory( rtems_filesystem_root.node_access, 0 );        
  fprintf(stdout, "***************      End of Dump       ***************\n" );
a00088f8:	ea00378a 	b	a0016728 <fwrite>                               <== NOT EXECUTED
                                                                      

a0008808 <IMFS_dump_directory>: */ void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) {
a0008808:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
 *                                                                    
 */                                                                   
int IMFS_memfile_maximum_size( void )                                 
{                                                                     
  return IMFS_MEMFILE_MAXIMUM_SIZE;                                   
}                                                                     
a000880c:	e5907050 	ldr	r7, [r0, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  Chain_Control *the_chain,                                           
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Tail(the_chain));                        
a0008810:	e2808054 	add	r8, r0, #84	; 0x54                            <== NOT EXECUTED
 */                                                                   
void IMFS_dump_directory(                                             
  IMFS_jnode_t  *the_directory,                                       
  int            level                                                
)                                                                     
{                                                                     
a0008814:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  IMFS_assert( level >= 0 );                                          
  IMFS_assert( the_directory->type == IMFS_DIRECTORY );               
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
a0008818:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
a000881c:	0a000015 	beq	a0008878 <IMFS_dump_directory+0x70>           <== NOT EXECUTED
a0008820:	e59f6064 	ldr	r6, [pc, #100]	; a000888c <IMFS_dump_directory+0x84><== NOT EXECUTED
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
a0008824:	e281a001 	add	sl, r1, #1                                    <== NOT EXECUTED
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
a0008828:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000882c:	ba000009 	blt	a0008858 <IMFS_dump_directory+0x50>           <== NOT EXECUTED
a0008830:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
      fprintf(stdout, "...." );                                       
a0008834:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a0008838:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
a000883c:	e0844001 	add	r4, r4, r1                                    <== NOT EXECUTED
      fprintf(stdout, "...." );                                       
a0008840:	e59f0048 	ldr	r0, [pc, #72]	; a0008890 <IMFS_dump_directory+0x88><== NOT EXECUTED
a0008844:	e3a02004 	mov	r2, #4                                        <== NOT EXECUTED
a0008848:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a000884c:	eb0037b5 	bl	a0016728 <fwrite>                              <== NOT EXECUTED
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
a0008850:	e1550004 	cmp	r5, r4                                        <== NOT EXECUTED
a0008854:	aafffff6 	bge	a0008834 <IMFS_dump_directory+0x2c>           <== NOT EXECUTED
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
a0008858:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000885c:	ebffffa0 	bl	a00086e4 <IMFS_print_jnode>                    <== NOT EXECUTED
    if ( the_jnode->type == IMFS_DIRECTORY )                          
a0008860:	e597304c 	ldr	r3, [r7, #76]	; 0x4c                          <== NOT EXECUTED
a0008864:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a0008868:	0a000003 	beq	a000887c <IMFS_dump_directory+0x74>           <== NOT EXECUTED
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
a000886c:	e5977000 	ldr	r7, [r7]                                      <== NOT EXECUTED
  IMFS_assert( level >= 0 );                                          
  IMFS_assert( the_directory->type == IMFS_DIRECTORY );               
                                                                      
  the_chain = &the_directory->info.directory.Entries;                 
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
a0008870:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
a0008874:	1affffeb 	bne	a0008828 <IMFS_dump_directory+0x20>           <== NOT EXECUTED
a0008878:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( the_jnode->type == IMFS_DIRECTORY )                          
      IMFS_dump_directory( the_jnode, level + 1 );                    
a000887c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0008880:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a0008884:	ebffffdf 	bl	a0008808 <IMFS_dump_directory>                 <== NOT EXECUTED
a0008888:	eafffff7 	b	a000886c <IMFS_dump_directory+0x64>             <== NOT EXECUTED
                                                                      

a000d95c <IMFS_eval_path>: const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
a000d95c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  char                                token[ IMFS_NAME_MAX + 1 ];     
  rtems_filesystem_location_info_t    newloc;                         
  IMFS_jnode_t                       *node;                           
  int                                 result;                         
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
a000d960:	e3d25007 	bics	r5, r2, #7                                   
  const char                        *pathname,     /* IN     */       
  size_t                             pathnamelen,  /* IN     */       
  int                                flags,        /* IN     */       
  rtems_filesystem_location_info_t  *pathloc       /* IN/OUT */       
                   )                                                  
{                                                                     
a000d964:	e24dd040 	sub	sp, sp, #64	; 0x40                            
a000d968:	e58d2000 	str	r2, [sp]                                      
a000d96c:	e1a0a000 	mov	sl, r0                                        
a000d970:	e1a04001 	mov	r4, r1                                        
a000d974:	e1a07003 	mov	r7, r3                                        
  char                                token[ IMFS_NAME_MAX + 1 ];     
  rtems_filesystem_location_info_t    newloc;                         
  IMFS_jnode_t                       *node;                           
  int                                 result;                         
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
a000d978:	1a000081 	bne	a000db84 <IMFS_eval_path+0x228>               
  /*                                                                  
   *  This was filled in by the caller and is valid in the            
   *  mount table.                                                    
   */                                                                 
                                                                      
  node = pathloc->node_access;                                        
a000d97c:	e5936000 	ldr	r6, [r3]                                      
a000d980:	e28d8004 	add	r8, sp, #4                                    
a000d984:	e28d903c 	add	r9, sp, #60	; 0x3c                            
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );  
a000d988:	e1a02008 	mov	r2, r8                                        
a000d98c:	e1a03009 	mov	r3, r9                                        
a000d990:	e08a0005 	add	r0, sl, r5                                    
a000d994:	e1a01004 	mov	r1, r4                                        
a000d998:	eb0001df 	bl	a000e11c <IMFS_get_token>                      
    pathnamelen -= len;                                               
    i += len;                                                         
                                                                      
    if ( !pathloc->node_access )                                      
a000d99c:	e5973000 	ldr	r3, [r7]                                      
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );  
a000d9a0:	e1a0b000 	mov	fp, r0                                        
    pathnamelen -= len;                                               
a000d9a4:	e59d203c 	ldr	r2, [sp, #60]	; 0x3c                          
    i += len;                                                         
                                                                      
    if ( !pathloc->node_access )                                      
a000d9a8:	e3530000 	cmp	r3, #0                                        
a000d9ac:	0a00004e 	beq	a000daec <IMFS_eval_path+0x190>               
      rtems_set_errno_and_return_minus_one( ENOENT );                 
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
a000d9b0:	e3500000 	cmp	r0, #0                                        
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
                                                                      
    type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );  
    pathnamelen -= len;                                               
a000d9b4:	e0624004 	rsb	r4, r2, r4                                    
    i += len;                                                         
a000d9b8:	e0855002 	add	r5, r5, r2                                    
      rtems_set_errno_and_return_minus_one( ENOENT );                 
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
a000d9bc:	1a00000f 	bne	a000da00 <IMFS_eval_path+0xa4>                
   *  new fs root node and let let the mounted filesystem set the handlers.
   *                                                                  
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
a000d9c0:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          
a000d9c4:	e3520001 	cmp	r2, #1                                        
a000d9c8:	0a000068 	beq	a000db70 <IMFS_eval_path+0x214>               
                                          flags, pathloc );           
    } else {                                                          
      result = IMFS_Set_handlers( pathloc );                          
    }                                                                 
  } else {                                                            
    result = IMFS_Set_handlers( pathloc );                            
a000d9cc:	e1a00007 	mov	r0, r7                                        
a000d9d0:	ebffff99 	bl	a000d83c <IMFS_Set_handlers>                   
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
a000d9d4:	e59d1000 	ldr	r1, [sp]                                      
                                          flags, pathloc );           
    } else {                                                          
      result = IMFS_Set_handlers( pathloc );                          
    }                                                                 
  } else {                                                            
    result = IMFS_Set_handlers( pathloc );                            
a000d9d8:	e1a06000 	mov	r6, r0                                        
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
a000d9dc:	e1a00007 	mov	r0, r7                                        
a000d9e0:	ebffffba 	bl	a000d8d0 <IMFS_evaluate_permission>            
a000d9e4:	e3500000 	cmp	r0, #0                                        
a000d9e8:	1a000036 	bne	a000dac8 <IMFS_eval_path+0x16c>               
    rtems_set_errno_and_return_minus_one( EACCES );                   
a000d9ec:	eb000dbb 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000d9f0:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
a000d9f4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000d9f8:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000d9fc:	ea000031 	b	a000dac8 <IMFS_eval_path+0x16c>                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
a000da00:	e596104c 	ldr	r1, [r6, #76]	; 0x4c                          
a000da04:	e3510001 	cmp	r1, #1                                        
a000da08:	0a000031 	beq	a000dad4 <IMFS_eval_path+0x178>               
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
          rtems_set_errno_and_return_minus_one( EACCES );             
                                                                      
    node = pathloc->node_access;                                      
                                                                      
    switch( type ) {                                                  
a000da0c:	e35b0003 	cmp	fp, #3                                        
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
          rtems_set_errno_and_return_minus_one( EACCES );             
                                                                      
    node = pathloc->node_access;                                      
a000da10:	e1a06003 	mov	r6, r3                                        
                                                                      
    switch( type ) {                                                  
a000da14:	0a000006 	beq	a000da34 <IMFS_eval_path+0xd8>                
a000da18:	e35b0004 	cmp	fp, #4                                        
a000da1c:	0a000025 	beq	a000dab8 <IMFS_eval_path+0x15c>               
a000da20:	e35b0002 	cmp	fp, #2                                        
a000da24:	0a000013 	beq	a000da78 <IMFS_eval_path+0x11c>               
                                                                      
  /*                                                                  
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
a000da28:	e35b0004 	cmp	fp, #4                                        
a000da2c:	1affffd5 	bne	a000d988 <IMFS_eval_path+0x2c>                
a000da30:	eaffffe2 	b	a000d9c0 <IMFS_eval_path+0x64>                  <== NOT EXECUTED
                                                                      
      case IMFS_NAME:                                                 
        /*                                                            
         *  If we are at a link follow it.                            
         */                                                           
        if ( node->type == IMFS_HARD_LINK ) {                         
a000da34:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
a000da38:	e3530003 	cmp	r3, #3                                        
a000da3c:	0a00002f 	beq	a000db00 <IMFS_eval_path+0x1a4>               
	   * It would be a design error if we evaluated the link and         
	   * was broken.                                                     
	   */                                                                
          IMFS_assert( node );                                        
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
a000da40:	e3530004 	cmp	r3, #4                                        
a000da44:	0a000058 	beq	a000dbac <IMFS_eval_path+0x250>               
        }                                                             
                                                                      
        /*                                                            
         *  Only a directory can be decended into.                    
         */                                                           
        if ( node->type != IMFS_DIRECTORY )                           
a000da48:	e3530001 	cmp	r3, #1                                        
a000da4c:	1a000051 	bne	a000db98 <IMFS_eval_path+0x23c>               
                                                                      
        /*                                                            
         *  If we are at a node that is a mount point. Set loc to the 
         *  new fs root node and let them finish evaluating the path. 
         */                                                           
        if ( node->info.directory.mt_fs != NULL ) {                   
a000da50:	e596e05c 	ldr	lr, [r6, #92]	; 0x5c                          
a000da54:	e35e0000 	cmp	lr, #0                                        
a000da58:	1a000047 	bne	a000db7c <IMFS_eval_path+0x220>               
        }                                                             
                                                                      
        /*                                                            
         *  Otherwise find the token name in the present location.    
         */                                                           
        node = IMFS_find_match_in_dir( node, token );                 
a000da5c:	e1a00006 	mov	r0, r6                                        
a000da60:	e1a01008 	mov	r1, r8                                        
a000da64:	eb00018b 	bl	a000e098 <IMFS_find_match_in_dir>              
        if ( !node )                                                  
a000da68:	e2506000 	subs	r6, r0, #0                                   
a000da6c:	0a00001e 	beq	a000daec <IMFS_eval_path+0x190>               
                                                                      
        /*                                                            
         *  Set the node access to the point we have found.           
         */                                                           
                                                                      
        pathloc->node_access = node;                                  
a000da70:	e5876000 	str	r6, [r7]                                      
a000da74:	eaffffc3 	b	a000d988 <IMFS_eval_path+0x2c>                  
      case IMFS_UP_DIR:                                               
        /*                                                            
         *  Am I at the root of all filesystems? (chroot'ed?)         
         */                                                           
                                                                      
        if ( pathloc->node_access == rtems_filesystem_root.node_access )
a000da78:	e59f1154 	ldr	r1, [pc, #340]	; a000dbd4 <IMFS_eval_path+0x278><== NOT EXECUTED
a000da7c:	e5912000 	ldr	r2, [r1]                                      <== NOT EXECUTED
a000da80:	e5922018 	ldr	r2, [r2, #24]                                 <== NOT EXECUTED
a000da84:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000da88:	0affffbe 	beq	a000d988 <IMFS_eval_path+0x2c>                <== NOT EXECUTED
        /*                                                            
         *  Am I at the root of this mounted filesystem?              
         */                                                           
                                                                      
        if (pathloc->node_access ==                                   
            pathloc->mt_entry->mt_fs_root.node_access) {              
a000da8c:	e597e010 	ldr	lr, [r7, #16]                                 <== NOT EXECUTED
                                                                      
        /*                                                            
         *  Am I at the root of this mounted filesystem?              
         */                                                           
                                                                      
        if (pathloc->node_access ==                                   
a000da90:	e59e201c 	ldr	r2, [lr, #28]                                 <== NOT EXECUTED
a000da94:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000da98:	0a00001e 	beq	a000db18 <IMFS_eval_path+0x1bc>               <== NOT EXECUTED
                                               pathnamelen+len,       
                                               flags,pathloc);        
          }                                                           
        } else {                                                      
                                                                      
          if ( !node->Parent )                                        
a000da9c:	e5936008 	ldr	r6, [r3, #8]                                  <== NOT EXECUTED
a000daa0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000daa4:	1afffff1 	bne	a000da70 <IMFS_eval_path+0x114>               <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one( ENOENT );           
a000daa8:	eb000d8c 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000daac:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000dab0:	e580b000 	str	fp, [r0]                                      <== NOT EXECUTED
a000dab4:	ea000003 	b	a000dac8 <IMFS_eval_path+0x16c>                 <== NOT EXECUTED
      case IMFS_NO_MORE_PATH:                                         
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
a000dab8:	eb000d88 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000dabc:	e3a0305b 	mov	r3, #91	; 0x5b                                <== NOT EXECUTED
a000dac0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000dac4:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, flags ) )                  
    rtems_set_errno_and_return_minus_one( EACCES );                   
                                                                      
  return result;                                                      
}                                                                     
a000dac8:	e1a00006 	mov	r0, r6                                        
a000dacc:	e28dd040 	add	sp, sp, #64	; 0x40                            
a000dad0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
a000dad4:	e1a00007 	mov	r0, r7                                        
a000dad8:	ebffff7c 	bl	a000d8d0 <IMFS_evaluate_permission>            
a000dadc:	e3500000 	cmp	r0, #0                                        
a000dae0:	0affffc1 	beq	a000d9ec <IMFS_eval_path+0x90>                
a000dae4:	e5973000 	ldr	r3, [r7]                                      
a000dae8:	eaffffc7 	b	a000da0c <IMFS_eval_path+0xb0>                  
        /*                                                            
         *  Otherwise find the token name in the present location.    
         */                                                           
        node = IMFS_find_match_in_dir( node, token );                 
        if ( !node )                                                  
          rtems_set_errno_and_return_minus_one( ENOENT );             
a000daec:	eb000d7b 	bl	a00110e0 <__errno>                             
a000daf0:	e3a03002 	mov	r3, #2                                        
a000daf4:	e5803000 	str	r3, [r0]                                      
a000daf8:	e3e06000 	mvn	r6, #0                                        
a000dafc:	eafffff1 	b	a000dac8 <IMFS_eval_path+0x16c>                 
      case IMFS_NAME:                                                 
        /*                                                            
         *  If we are at a link follow it.                            
         */                                                           
        if ( node->type == IMFS_HARD_LINK ) {                         
          IMFS_evaluate_hard_link( pathloc, 0 );                      
a000db00:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000db04:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000db08:	ebffff80 	bl	a000d910 <IMFS_evaluate_hard_link>             <== NOT EXECUTED
          node = pathloc->node_access;                                
a000db0c:	e5976000 	ldr	r6, [r7]                                      <== NOT EXECUTED
a000db10:	e596304c 	ldr	r3, [r6, #76]	; 0x4c                          <== NOT EXECUTED
a000db14:	eaffffcb 	b	a000da48 <IMFS_eval_path+0xec>                  <== NOT EXECUTED
           */                                                         
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;       /* Throw out the .. in this case */          
          } else {                                                    
            newloc = pathloc->mt_entry->mt_point_node;                
a000db18:	e28ee008 	add	lr, lr, #8                                    <== NOT EXECUTED
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
    if ( node->info.directory.mt_fs != NULL ) {                       
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
a000db1c:	e28d6028 	add	r6, sp, #40	; 0x28                            <== NOT EXECUTED
a000db20:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000db24:	e8a6000f 	stmia	r6!, {r0, r1, r2, r3}                       <== NOT EXECUTED
      *pathloc = newloc;                                              
a000db28:	e28dc028 	add	ip, sp, #40	; 0x28                            <== NOT EXECUTED
a000db2c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
    if ( node->info.directory.mt_fs != NULL ) {                       
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
a000db30:	e59ec000 	ldr	ip, [lr]                                      <== NOT EXECUTED
      *pathloc = newloc;                                              
a000db34:	e1a0e007 	mov	lr, r7                                        <== NOT EXECUTED
a000db38:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
a000db3c:	e59d103c 	ldr	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
    if ( node->info.directory.mt_fs != NULL ) {                       
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
      *pathloc = newloc;                                              
a000db40:	e58ec000 	str	ip, [lr]                                      <== NOT EXECUTED
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
a000db44:	e597300c 	ldr	r3, [r7, #12]                                 <== NOT EXECUTED
a000db48:	e0610005 	rsb	r0, r1, r5                                    <== NOT EXECUTED
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
    if ( node->info.directory.mt_fs != NULL ) {                       
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
a000db4c:	e586c000 	str	ip, [r6]                                      <== NOT EXECUTED
      *pathloc = newloc;                                              
      return (*pathloc->ops->evalpath_h)( &pathname[i-len],           
a000db50:	e08a0000 	add	r0, sl, r0                                    <== NOT EXECUTED
a000db54:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a000db58:	e0841001 	add	r1, r4, r1                                    <== NOT EXECUTED
a000db5c:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a000db60:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a000db64:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
a000db68:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a000db6c:	eaffffd5 	b	a000dac8 <IMFS_eval_path+0x16c>                 <== NOT EXECUTED
   *                                                                  
   *  NOTE: The behavior of stat() on a mount point appears to be questionable.
   */                                                                 
                                                                      
  if ( node->type == IMFS_DIRECTORY ) {                               
    if ( node->info.directory.mt_fs != NULL ) {                       
a000db70:	e593e05c 	ldr	lr, [r3, #92]	; 0x5c                          
a000db74:	e35e0000 	cmp	lr, #0                                        
a000db78:	0affff93 	beq	a000d9cc <IMFS_eval_path+0x70>                
      newloc   = node->info.directory.mt_fs->mt_fs_root;              
a000db7c:	e28ee01c 	add	lr, lr, #28                                   <== NOT EXECUTED
a000db80:	eaffffe5 	b	a000db1c <IMFS_eval_path+0x1c0>                 <== NOT EXECUTED
  rtems_filesystem_location_info_t    newloc;                         
  IMFS_jnode_t                       *node;                           
  int                                 result;                         
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) ) {                       
    rtems_set_errno_and_return_minus_one( EIO );                      
a000db84:	eb000d55 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000db88:	e3a03005 	mov	r3, #5                                        <== NOT EXECUTED
a000db8c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000db90:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000db94:	eaffffcb 	b	a000dac8 <IMFS_eval_path+0x16c>                 <== NOT EXECUTED
                                                                      
        /*                                                            
         *  Only a directory can be decended into.                    
         */                                                           
        if ( node->type != IMFS_DIRECTORY )                           
          rtems_set_errno_and_return_minus_one( ENOTDIR );            
a000db98:	eb000d50 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000db9c:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a000dba0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000dba4:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000dba8:	eaffffc6 	b	a000dac8 <IMFS_eval_path+0x16c>                 <== NOT EXECUTED
	   * was broken.                                                     
	   */                                                                
          IMFS_assert( node );                                        
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
a000dbac:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000dbb0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000dbb4:	eb000007 	bl	a000dbd8 <IMFS_evaluate_sym_link>              <== NOT EXECUTED
          /*                                                          
           *  In contrast to a hard link, it is possible to have a broken
           *  symbolic link.                                          
           */                                                         
          node = pathloc->node_access;                                
          if ( result == -1 )                                         
a000dbb8:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
	   * was broken.                                                     
	   */                                                                
          IMFS_assert( node );                                        
                                                                      
        } else if ( node->type == IMFS_SYM_LINK ) {                   
          result = IMFS_evaluate_sym_link( pathloc, 0 );              
a000dbbc:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
          /*                                                          
           *  In contrast to a hard link, it is possible to have a broken
           *  symbolic link.                                          
           */                                                         
          node = pathloc->node_access;                                
a000dbc0:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
          if ( result == -1 )                                         
a000dbc4:	0affffbf 	beq	a000dac8 <IMFS_eval_path+0x16c>               <== NOT EXECUTED
                                                                      
          /*                                                          
           *  In contrast to a hard link, it is possible to have a broken
           *  symbolic link.                                          
           */                                                         
          node = pathloc->node_access;                                
a000dbc8:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
a000dbcc:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a000dbd0:	eaffff9c 	b	a000da48 <IMFS_eval_path+0xec>                  <== NOT EXECUTED
                                                                      

a000dd40 <IMFS_evaluate_for_make>: int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) {
a000dd40:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
a000dd44:	e24dd040 	sub	sp, sp, #64	; 0x40                            
a000dd48:	e1a06001 	mov	r6, r1                                        
                                                                      
  /*                                                                  
   * This was filled in by the caller and is valid in the             
   * mount table.                                                     
   */                                                                 
  node = pathloc->node_access;                                        
a000dd4c:	e5915000 	ldr	r5, [r1]                                      
int IMFS_evaluate_for_make(                                           
   const char                         *path,       /* IN     */       
   rtems_filesystem_location_info_t   *pathloc,    /* IN/OUT */       
   const char                        **name        /* OUT    */       
)                                                                     
{                                                                     
a000dd50:	e1a0a000 	mov	sl, r0                                        
a000dd54:	e58d2000 	str	r2, [sp]                                      
  node = pathloc->node_access;                                        
                                                                      
  /*                                                                  
   * Get the path length.                                             
   */                                                                 
  pathlen = strlen( path );                                           
a000dd58:	eb0010ca 	bl	a0012088 <strlen>                              
   const char                         *path,       /* IN     */       
   rtems_filesystem_location_info_t   *pathloc,    /* IN/OUT */       
   const char                        **name        /* OUT    */       
)                                                                     
{                                                                     
  int                                 i = 0;                          
a000dd5c:	e3a07000 	mov	r7, #0                                        
  node = pathloc->node_access;                                        
                                                                      
  /*                                                                  
   * Get the path length.                                             
   */                                                                 
  pathlen = strlen( path );                                           
a000dd60:	e1a04000 	mov	r4, r0                                        
a000dd64:	e28d8004 	add	r8, sp, #4                                    
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
a000dd68:	e1a01004 	mov	r1, r4                                        
a000dd6c:	e28d303c 	add	r3, sp, #60	; 0x3c                            
a000dd70:	e08a0007 	add	r0, sl, r7                                    
a000dd74:	e1a02008 	mov	r2, r8                                        
a000dd78:	eb0000e7 	bl	a000e11c <IMFS_get_token>                      
    pathlen -= len;                                                   
    i +=  len;                                                        
                                                                      
    if ( !pathloc->node_access )                                      
a000dd7c:	e5963000 	ldr	r3, [r6]                                      
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    pathlen -= len;                                                   
a000dd80:	e59db03c 	ldr	fp, [sp, #60]	; 0x3c                          
   *  Evaluate all tokens until we are done or an error occurs.       
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
a000dd84:	e1a09000 	mov	r9, r0                                        
    pathlen -= len;                                                   
    i +=  len;                                                        
                                                                      
    if ( !pathloc->node_access )                                      
a000dd88:	e3530000 	cmp	r3, #0                                        
   */                                                                 
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    pathlen -= len;                                                   
a000dd8c:	e06b4004 	rsb	r4, fp, r4                                    
    i +=  len;                                                        
                                                                      
    if ( !pathloc->node_access )                                      
a000dd90:	0a000035 	beq	a000de6c <IMFS_evaluate_for_make+0x12c>       
                                                                      
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
                                                                      
    if ( type != IMFS_NO_MORE_PATH )                                  
a000dd94:	e3500000 	cmp	r0, #0                                        
a000dd98:	1a000006 	bne	a000ddb8 <IMFS_evaluate_for_make+0x78>        
          pathloc->node_access = node;                                
                                                                      
        break;                                                        
                                                                      
      case IMFS_NO_MORE_PATH:                                         
        rtems_set_errno_and_return_minus_one( EEXIST );               
a000dd9c:	eb000ccf 	bl	a00110e0 <__errno>                             
a000dda0:	e3a03011 	mov	r3, #17                                       
a000dda4:	e5803000 	str	r3, [r0]                                      
a000dda8:	e3e05000 	mvn	r5, #0                                        
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )   
    rtems_set_errno_and_return_minus_one( EACCES );                   
                                                                      
  return result;                                                      
}                                                                     
a000ddac:	e1a00005 	mov	r0, r5                                        
a000ddb0:	e28dd040 	add	sp, sp, #64	; 0x40                            
a000ddb4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    /*                                                                
     * I cannot move out of this directory without execute permission.
     */                                                               
                                                                      
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
a000ddb8:	e595104c 	ldr	r1, [r5, #76]	; 0x4c                          
a000ddbc:	e3510001 	cmp	r1, #1                                        
a000ddc0:	0a000044 	beq	a000ded8 <IMFS_evaluate_for_make+0x198>       
                                                                      
  while( !done ) {                                                    
                                                                      
    type = IMFS_get_token( &path[i], pathlen, token, &len );          
    pathlen -= len;                                                   
    i +=  len;                                                        
a000ddc4:	e087700b 	add	r7, r7, fp                                    
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
           rtems_set_errno_and_return_minus_one( EACCES );            
                                                                      
    node = pathloc->node_access;                                      
a000ddc8:	e1a05003 	mov	r5, r3                                        
                                                                      
    switch( type ) {                                                  
a000ddcc:	e3590004 	cmp	r9, #4                                        
a000ddd0:	979ff109 	ldrls	pc, [pc, r9, lsl #2]                        
a000ddd4:	eaffffe3 	b	a000dd68 <IMFS_evaluate_for_make+0x28>          <== NOT EXECUTED
a000ddd8:	a000dd9c 	.word	0xa000dd9c                                  <== NOT EXECUTED
a000dddc:	a000dd68 	.word	0xa000dd68                                  <== NOT EXECUTED
a000dde0:	a000de3c 	.word	0xa000de3c                                  <== NOT EXECUTED
a000dde4:	a000ddec 	.word	0xa000ddec                                  <== NOT EXECUTED
a000dde8:	a000de80 	.word	0xa000de80                                  <== NOT EXECUTED
        pathloc->node_access = node;                                  
        break;                                                        
                                                                      
      case IMFS_NAME:                                                 
                                                                      
	if ( node->type == IMFS_HARD_LINK ) {                                
a000ddec:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
a000ddf0:	e3530003 	cmp	r3, #3                                        
a000ddf4:	0a00006a 	beq	a000dfa4 <IMFS_evaluate_for_make+0x264>       
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
a000ddf8:	e3530004 	cmp	r3, #4                                        
a000ddfc:	0a000068 	beq	a000dfa4 <IMFS_evaluate_for_make+0x264>       
          if ( result == -1 )                                         
            return -1;                                                
	}                                                                    
                                                                      
        node = pathloc->node_access;                                  
        if ( !node )                                                  
a000de00:	e3550000 	cmp	r5, #0                                        
a000de04:	0a00005f 	beq	a000df88 <IMFS_evaluate_for_make+0x248>       
                                                                      
        /*                                                            
         * Only a directory can be decended into.                     
	 */                                                                  
                                                                      
        if ( node->type != IMFS_DIRECTORY )                           
a000de08:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          
a000de0c:	e3530001 	cmp	r3, #1                                        
a000de10:	1a00005c 	bne	a000df88 <IMFS_evaluate_for_make+0x248>       
	/*                                                                   
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
a000de14:	e595c05c 	ldr	ip, [r5, #92]	; 0x5c                          
a000de18:	e35c0000 	cmp	ip, #0                                        
a000de1c:	1a00005e 	bne	a000df9c <IMFS_evaluate_for_make+0x25c>       
                                                                      
	/*                                                                   
	 * Otherwise find the token name in the present location.            
	 */                                                                  
                                                                      
        node = IMFS_find_match_in_dir( node, token );                 
a000de20:	e1a00005 	mov	r0, r5                                        
a000de24:	e1a01008 	mov	r1, r8                                        
a000de28:	eb00009a 	bl	a000e098 <IMFS_find_match_in_dir>              
	/*                                                                   
	 * If there is no node we have found the name of the node we         
         * wish to create.                                            
	 */                                                                  
                                                                      
        if ( ! node )                                                 
a000de2c:	e2505000 	subs	r5, r0, #0                                   
a000de30:	0a000017 	beq	a000de94 <IMFS_evaluate_for_make+0x154>       
          done = true;                                                
        else                                                          
          pathloc->node_access = node;                                
a000de34:	e5865000 	str	r5, [r6]                                      
a000de38:	eaffffca 	b	a000dd68 <IMFS_evaluate_for_make+0x28>          
      case IMFS_UP_DIR:                                               
       /*                                                             
        *  Am I at the root of all filesystems? (chroot'ed?)          
	*/                                                                   
                                                                      
       if ( pathloc->node_access == rtems_filesystem_root.node_access )
a000de3c:	e59f1180 	ldr	r1, [pc, #384]	; a000dfc4 <IMFS_evaluate_for_make+0x284><== NOT EXECUTED
a000de40:	e5912000 	ldr	r2, [r1]                                      <== NOT EXECUTED
a000de44:	e5922018 	ldr	r2, [r2, #24]                                 <== NOT EXECUTED
a000de48:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000de4c:	0affffc5 	beq	a000dd68 <IMFS_evaluate_for_make+0x28>        <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * Am I at the root of this mounted filesystem?                      
	 */                                                                  
                                                                      
        if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
a000de50:	e596c010 	ldr	ip, [r6, #16]                                 <== NOT EXECUTED
a000de54:	e59c201c 	ldr	r2, [ip, #28]                                 <== NOT EXECUTED
a000de58:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000de5c:	0a000023 	beq	a000def0 <IMFS_evaluate_for_make+0x1b0>       <== NOT EXECUTED
            *pathloc = newloc;                                        
            return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
	  }                                                                  
	} else {                                                             
                                                                      
          if ( !node->Parent )                                        
a000de60:	e5935008 	ldr	r5, [r3, #8]                                  <== NOT EXECUTED
a000de64:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000de68:	1afffff1 	bne	a000de34 <IMFS_evaluate_for_make+0xf4>        <== NOT EXECUTED
   * Verify there is not any invalid stuff at the end of the name.    
   */                                                                 
                                                                      
  for( ; path[i] != '\0'; i++) {                                      
    if ( !IMFS_is_separator( path[ i ] ) )                            
      rtems_set_errno_and_return_minus_one( ENOENT );                 
a000de6c:	eb000c9b 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000de70:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
a000de74:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000de78:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a000de7c:	eaffffca 	b	a000ddac <IMFS_evaluate_for_make+0x6c>          <== NOT EXECUTED
      case IMFS_NO_MORE_PATH:                                         
        rtems_set_errno_and_return_minus_one( EEXIST );               
        break;                                                        
                                                                      
      case IMFS_INVALID_TOKEN:                                        
        rtems_set_errno_and_return_minus_one( ENAMETOOLONG );         
a000de80:	eb000c96 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000de84:	e3a0305b 	mov	r3, #91	; 0x5b                                <== NOT EXECUTED
a000de88:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000de8c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a000de90:	eaffffc5 	b	a000ddac <IMFS_evaluate_for_make+0x6c>          <== NOT EXECUTED
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  *name = &path[ i - len ];                                           
a000de94:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          
a000de98:	e59d1000 	ldr	r1, [sp]                                      
  /*                                                                  
   * We have evaluated the path as far as we can.                     
   * Verify there is not any invalid stuff at the end of the name.    
   */                                                                 
                                                                      
  for( ; path[i] != '\0'; i++) {                                      
a000de9c:	e08a4007 	add	r4, sl, r7                                    
      case IMFS_CURRENT_DIR:                                          
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  *name = &path[ i - len ];                                           
a000dea0:	e0633007 	rsb	r3, r3, r7                                    
a000dea4:	e08a3003 	add	r3, sl, r3                                    
a000dea8:	e5813000 	str	r3, [r1]                                      
  /*                                                                  
   * We have evaluated the path as far as we can.                     
   * Verify there is not any invalid stuff at the end of the name.    
   */                                                                 
                                                                      
  for( ; path[i] != '\0'; i++) {                                      
a000deac:	e7da0007 	ldrb	r0, [sl, r7]                                 
a000deb0:	e3500000 	cmp	r0, #0                                        
a000deb4:	1a000003 	bne	a000dec8 <IMFS_evaluate_for_make+0x188>       
a000deb8:	ea000021 	b	a000df44 <IMFS_evaluate_for_make+0x204>         
a000debc:	e5f40001 	ldrb	r0, [r4, #1]!                                <== NOT EXECUTED
a000dec0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000dec4:	0a00001e 	beq	a000df44 <IMFS_evaluate_for_make+0x204>       <== NOT EXECUTED
    if ( !IMFS_is_separator( path[ i ] ) )                            
a000dec8:	ebffe4f7 	bl	a00072ac <rtems_filesystem_is_separator>       <== NOT EXECUTED
a000decc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ded0:	1afffff9 	bne	a000debc <IMFS_evaluate_for_make+0x17c>       <== NOT EXECUTED
a000ded4:	eaffffe4 	b	a000de6c <IMFS_evaluate_for_make+0x12c>         <== NOT EXECUTED
     * I cannot move out of this directory without execute permission.
     */                                                               
                                                                      
    if ( type != IMFS_NO_MORE_PATH )                                  
      if ( node->type == IMFS_DIRECTORY )                             
        if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
a000ded8:	e1a00006 	mov	r0, r6                                        
a000dedc:	ebfffe7b 	bl	a000d8d0 <IMFS_evaluate_permission>            
a000dee0:	e3500000 	cmp	r0, #0                                        
a000dee4:	0a000022 	beq	a000df74 <IMFS_evaluate_for_make+0x234>       
a000dee8:	e5963000 	ldr	r3, [r6]                                      
a000deec:	eaffffb4 	b	a000ddc4 <IMFS_evaluate_for_make+0x84>          
                                                                      
          if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
            break;                                                    
                                                                      
	  } else {                                                           
            newloc = pathloc->mt_entry->mt_point_node;                
a000def0:	e28cc008 	add	ip, ip, #8                                    <== NOT EXECUTED
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
a000def4:	e28d4028 	add	r4, sp, #40	; 0x28                            <== NOT EXECUTED
a000def8:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000defc:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}                       <== NOT EXECUTED
          *pathloc = newloc;                                          
a000df00:	e28de028 	add	lr, sp, #40	; 0x28                            <== NOT EXECUTED
a000df04:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000df08:	e1a0e006 	mov	lr, r6                                        <== NOT EXECUTED
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
a000df0c:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
          *pathloc = newloc;                                          
a000df10:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
          return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a000df14:	e59d003c 	ldr	r0, [sp, #60]	; 0x3c                          <== NOT EXECUTED
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
          *pathloc = newloc;                                          
a000df18:	e58ec000 	str	ip, [lr]                                      <== NOT EXECUTED
          return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a000df1c:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
a000df20:	e0600007 	rsb	r0, r0, r7                                    <== NOT EXECUTED
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
a000df24:	e584c000 	str	ip, [r4]                                      <== NOT EXECUTED
          *pathloc = newloc;                                          
          return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a000df28:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000df2c:	e08a0000 	add	r0, sl, r0                                    <== NOT EXECUTED
a000df30:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000df34:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a000df38:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000df3c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000df40:	eaffff99 	b	a000ddac <IMFS_evaluate_for_make+0x6c>          <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify we can execute and write to this directory.               
   */                                                                 
                                                                      
  result = IMFS_Set_handlers( pathloc );                              
a000df44:	e1a00006 	mov	r0, r6                                        
a000df48:	ebfffe3b 	bl	a000d83c <IMFS_Set_handlers>                   
                                                                      
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
  if ( node->type != IMFS_DIRECTORY )                                 
a000df4c:	e5963000 	ldr	r3, [r6]                                      
                                                                      
  /*                                                                  
   * Verify we can execute and write to this directory.               
   */                                                                 
                                                                      
  result = IMFS_Set_handlers( pathloc );                              
a000df50:	e1a05000 	mov	r5, r0                                        
                                                                      
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
  if ( node->type != IMFS_DIRECTORY )                                 
a000df54:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          
a000df58:	e3530001 	cmp	r3, #1                                        
a000df5c:	1a000009 	bne	a000df88 <IMFS_evaluate_for_make+0x248>       
                                                                      
  /*                                                                  
   * We must have Write and execute permission on the returned node.  
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )   
a000df60:	e1a00006 	mov	r0, r6                                        
a000df64:	e3a01003 	mov	r1, #3                                        
a000df68:	ebfffe58 	bl	a000d8d0 <IMFS_evaluate_permission>            
a000df6c:	e3500000 	cmp	r0, #0                                        
a000df70:	1affff8d 	bne	a000ddac <IMFS_evaluate_for_make+0x6c>        
    rtems_set_errno_and_return_minus_one( EACCES );                   
a000df74:	eb000c59 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000df78:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
a000df7c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000df80:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a000df84:	eaffff88 	b	a000ddac <IMFS_evaluate_for_make+0x6c>          <== NOT EXECUTED
  /*                                                                  
   * The returned node must be a directory                            
   */                                                                 
  node = pathloc->node_access;                                        
  if ( node->type != IMFS_DIRECTORY )                                 
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a000df88:	eb000c54 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000df8c:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a000df90:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000df94:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a000df98:	eaffff83 	b	a000ddac <IMFS_evaluate_for_make+0x6c>          <== NOT EXECUTED
	 * If we are at a node that is a mount point. Set loc to the         
	 * new fs root node and let them finish evaluating the path.         
	 */                                                                  
                                                                      
        if ( node->info.directory.mt_fs != NULL ) {                   
          newloc  = node->info.directory.mt_fs->mt_fs_root;           
a000df9c:	e28cc01c 	add	ip, ip, #28                                   <== NOT EXECUTED
a000dfa0:	eaffffd3 	b	a000def4 <IMFS_evaluate_for_make+0x1b4>         <== NOT EXECUTED
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
a000dfa4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000dfa8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000dfac:	ebffff2e 	bl	a000dc6c <IMFS_evaluate_link>                  <== NOT EXECUTED
                                                                      
          if ( result == -1 )                                         
a000dfb0:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
          if ( result == -1 )                                         
            return -1;                                                
                                                                      
	} else if ( node->type == IMFS_SYM_LINK ) {                          
                                                                      
          result = IMFS_evaluate_link( pathloc, 0 );                  
a000dfb4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
          if ( result == -1 )                                         
a000dfb8:	0affff7b 	beq	a000ddac <IMFS_evaluate_for_make+0x6c>        <== NOT EXECUTED
a000dfbc:	e5965000 	ldr	r5, [r6]                                      <== NOT EXECUTED
a000dfc0:	eaffff8e 	b	a000de00 <IMFS_evaluate_for_make+0xc0>          <== NOT EXECUTED
                                                                      

a000d910 <IMFS_evaluate_hard_link>: int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
a000d910:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_assert( jnode->type == IMFS_HARD_LINK );                       
                                                                      
  /*                                                                  
   * Set the hard link value and the handlers.                        
   */                                                                 
  node->node_access = jnode->info.hard_link.link_node;                
a000d914:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
                                                                      
int IMFS_evaluate_hard_link(                                          
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
a000d918:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000d91c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  IMFS_assert( jnode->type == IMFS_HARD_LINK );                       
                                                                      
  /*                                                                  
   * Set the hard link value and the handlers.                        
   */                                                                 
  node->node_access = jnode->info.hard_link.link_node;                
a000d920:	e5933050 	ldr	r3, [r3, #80]	; 0x50                          <== NOT EXECUTED
a000d924:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  IMFS_Set_handlers( node );                                          
a000d928:	ebffffc3 	bl	a000d83c <IMFS_Set_handlers>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
a000d92c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d930:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000d934:	ebffffe5 	bl	a000d8d0 <IMFS_evaluate_permission>            <== NOT EXECUTED
a000d938:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000d93c:	0a000001 	beq	a000d948 <IMFS_evaluate_hard_link+0x38>       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EACCES );                   
                                                                      
  return result;                                                      
a000d940:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a000d944:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
                                                                      
  if ( !IMFS_evaluate_permission( node, flags ) )                     
    rtems_set_errno_and_return_minus_one( EACCES );                   
a000d948:	eb000de4 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000d94c:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
a000d950:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000d954:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000d958:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000dc6c <IMFS_evaluate_link>: */ int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
a000dc6c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
    if ( rtems_filesystem_link_counts > MAXSYMLINK ) {                
      rtems_filesystem_link_counts = 0;                               
      rtems_set_errno_and_return_minus_one( ELOOP );                  
a000dc70:	e59f60c4 	ldr	r6, [pc, #196]	; a000dd3c <IMFS_evaluate_link+0xd0><== NOT EXECUTED
 */                                                                   
int IMFS_evaluate_link(                                               
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
a000dc74:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000dc78:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
    if ( rtems_filesystem_link_counts > MAXSYMLINK ) {                
      rtems_filesystem_link_counts = 0;                               
      rtems_set_errno_and_return_minus_one( ELOOP );                  
a000dc7c:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
a000dc80:	ea000004 	b	a000dc98 <IMFS_evaluate_link+0x2c>              <== NOT EXECUTED
     */                                                               
                                                                      
    if ( jnode->type == IMFS_HARD_LINK )                              
      result = IMFS_evaluate_hard_link( node, flags );                
                                                                      
    else if (jnode->type == IMFS_SYM_LINK )                           
a000dc84:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a000dc88:	0a00001b 	beq	a000dcfc <IMFS_evaluate_link+0x90>            <== NOT EXECUTED
      result = IMFS_evaluate_sym_link( node, flags );                 
                                                                      
  } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK  ) || 
a000dc8c:	e2433003 	sub	r3, r3, #3                                    <== NOT EXECUTED
a000dc90:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000dc94:	8a000014 	bhi	a000dcec <IMFS_evaluate_link+0x80>            <== NOT EXECUTED
                                                                      
    /*                                                                
     * Increment and check the link counter.                          
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
a000dc98:	e1d233b0 	ldrh	r3, [r2, #48]	; 0x30                         <== NOT EXECUTED
{                                                                     
  IMFS_jnode_t                     *jnode;                            
  int                               result = 0;                       
                                                                      
  do {                                                                
    jnode  = node->node_access;                                       
a000dc9c:	e5954000 	ldr	r4, [r5]                                      <== NOT EXECUTED
                                                                      
    /*                                                                
     * Increment and check the link counter.                          
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
a000dca0:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000dca4:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
a000dca8:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
    if ( rtems_filesystem_link_counts > MAXSYMLINK ) {                
a000dcac:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     * Increment and check the link counter.                          
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
a000dcb0:	e1c233b0 	strh	r3, [r2, #48]	; 0x30                         <== NOT EXECUTED
    if ( rtems_filesystem_link_counts > MAXSYMLINK ) {                
a000dcb4:	8a000019 	bhi	a000dd20 <IMFS_evaluate_link+0xb4>            <== NOT EXECUTED
                                                                      
    /*                                                                
     *  Follow the Link node.                                         
     */                                                               
                                                                      
    if ( jnode->type == IMFS_HARD_LINK )                              
a000dcb8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000dcbc:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a000dcc0:	1affffef 	bne	a000dc84 <IMFS_evaluate_link+0x18>            <== NOT EXECUTED
      result = IMFS_evaluate_hard_link( node, flags );                
a000dcc4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000dcc8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000dccc:	ebffff0f 	bl	a000d910 <IMFS_evaluate_hard_link>             <== NOT EXECUTED
                                                                      
    else if (jnode->type == IMFS_SYM_LINK )                           
      result = IMFS_evaluate_sym_link( node, flags );                 
                                                                      
  } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK  ) || 
                                 ( jnode->type == IMFS_HARD_LINK ) ) );
a000dcd0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000dcd4:	1a00000d 	bne	a000dd10 <IMFS_evaluate_link+0xa4>            <== NOT EXECUTED
a000dcd8:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000dcdc:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
      result = IMFS_evaluate_hard_link( node, flags );                
                                                                      
    else if (jnode->type == IMFS_SYM_LINK )                           
      result = IMFS_evaluate_sym_link( node, flags );                 
                                                                      
  } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK  ) || 
a000dce0:	e2433003 	sub	r3, r3, #3                                    <== NOT EXECUTED
a000dce4:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000dce8:	9affffea 	bls	a000dc98 <IMFS_evaluate_link+0x2c>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Clear link counter.                                              
   */                                                                 
                                                                      
  rtems_filesystem_link_counts = 0;                                   
a000dcec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      result = IMFS_evaluate_hard_link( node, flags );                
                                                                      
    else if (jnode->type == IMFS_SYM_LINK )                           
      result = IMFS_evaluate_sym_link( node, flags );                 
                                                                      
  } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK  ) || 
a000dcf0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Clear link counter.                                              
   */                                                                 
                                                                      
  rtems_filesystem_link_counts = 0;                                   
a000dcf4:	e1c233b0 	strh	r3, [r2, #48]	; 0x30                         <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a000dcf8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
    if ( jnode->type == IMFS_HARD_LINK )                              
      result = IMFS_evaluate_hard_link( node, flags );                
                                                                      
    else if (jnode->type == IMFS_SYM_LINK )                           
      result = IMFS_evaluate_sym_link( node, flags );                 
a000dcfc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000dd00:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000dd04:	ebffffb3 	bl	a000dbd8 <IMFS_evaluate_sym_link>              <== NOT EXECUTED
                                                                      
  } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK  ) || 
                                 ( jnode->type == IMFS_HARD_LINK ) ) );
a000dd08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000dd0c:	0afffff1 	beq	a000dcd8 <IMFS_evaluate_link+0x6c>            <== NOT EXECUTED
a000dd10:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Clear link counter.                                              
   */                                                                 
                                                                      
  rtems_filesystem_link_counts = 0;                                   
a000dd14:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000dd18:	e1c233b0 	strh	r3, [r2, #48]	; 0x30                         <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a000dd1c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
     * Increment and check the link counter.                          
     */                                                               
                                                                      
    rtems_filesystem_link_counts ++;                                  
    if ( rtems_filesystem_link_counts > MAXSYMLINK ) {                
      rtems_filesystem_link_counts = 0;                               
a000dd20:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000dd24:	e1c233b0 	strh	r3, [r2, #48]	; 0x30                         <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ELOOP );                  
a000dd28:	eb000cec 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000dd2c:	e3a0305c 	mov	r3, #92	; 0x5c                                <== NOT EXECUTED
a000dd30:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000dd34:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000dd38:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000d8d0 <IMFS_evaluate_permission>: uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) )
a000d8d0:	e3d13007 	bics	r3, r1, #7                                   
 */                                                                   
int IMFS_evaluate_permission(                                         
  rtems_filesystem_location_info_t  *node,                            
  int                                flags                            
)                                                                     
{                                                                     
a000d8d4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  uid_t         st_uid;                                               
  gid_t         st_gid;                                               
  IMFS_jnode_t *jnode;                                                
  int           flags_to_test;                                        
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) )                         
a000d8d8:	1a000007 	bne	a000d8fc <IMFS_evaluate_permission+0x2c>      
                                                                      
  /*                                                                  
   * If all of the flags are set we have permission                   
   * to do this.                                                      
   */                                                                 
  if ( ( flags_to_test & jnode->st_mode) == flags_to_test )           
a000d8dc:	e5903000 	ldr	r3, [r0]                                      
   */                                                                 
                                                                      
  flags_to_test = flags;                                              
                                                                      
  if ( st_uid == jnode->st_uid )                                      
    flags_to_test <<= 6;                                              
a000d8e0:	e1a01301 	lsl	r1, r1, #6                                    
                                                                      
  /*                                                                  
   * If all of the flags are set we have permission                   
   * to do this.                                                      
   */                                                                 
  if ( ( flags_to_test & jnode->st_mode) == flags_to_test )           
a000d8e4:	e5930030 	ldr	r0, [r3, #48]	; 0x30                          
a000d8e8:	e0010000 	and	r0, r1, r0                                    
  gid_t         st_gid;                                               
  IMFS_jnode_t *jnode;                                                
  int           flags_to_test;                                        
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    rtems_set_errno_and_return_minus_one( EPERM );                    
a000d8ec:	e1510000 	cmp	r1, r0                                        
a000d8f0:	13a00000 	movne	r0, #0                                      
a000d8f4:	03a00001 	moveq	r0, #1                                      
   */                                                                 
  if ( ( flags_to_test & jnode->st_mode) == flags_to_test )           
    return 1;                                                         
                                                                      
  return 0;                                                           
}                                                                     
a000d8f8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
  gid_t         st_gid;                                               
  IMFS_jnode_t *jnode;                                                
  int           flags_to_test;                                        
                                                                      
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    rtems_set_errno_and_return_minus_one( EPERM );                    
a000d8fc:	eb000df7 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000d900:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000d904:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000d908:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000d90c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000dbd8 <IMFS_evaluate_sym_link>: int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) {
a000dbd8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  IMFS_jnode_t                     *jnode  = node->node_access;       
a000dbdc:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
                                                                      
int IMFS_evaluate_sym_link(                                           
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
a000dbe0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000dbe4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Move the node_access to either the symbolic links parent or      
   * root depending on the symbolic links path.                       
   */                                                                 
  node->node_access = jnode->Parent;                                  
a000dbe8:	e5963008 	ldr	r3, [r6, #8]                                  <== NOT EXECUTED
                                                                      
  rtems_filesystem_get_sym_start_loc(                                 
a000dbec:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
                                                                      
int IMFS_evaluate_sym_link(                                           
  rtems_filesystem_location_info_t  *node,   /* IN/OUT */             
  int                                flags   /* IN     */             
)                                                                     
{                                                                     
a000dbf0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Move the node_access to either the symbolic links parent or      
   * root depending on the symbolic links path.                       
   */                                                                 
  node->node_access = jnode->Parent;                                  
a000dbf4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  rtems_filesystem_get_sym_start_loc(                                 
a000dbf8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000dbfc:	e5960050 	ldr	r0, [r6, #80]	; 0x50                          <== NOT EXECUTED
a000dc00:	eb0003ac 	bl	a000eab8 <rtems_filesystem_get_sym_start_loc>  <== NOT EXECUTED
  );                                                                  
                                                                      
  /*                                                                  
   * Use eval path to evaluate the path of the symbolic link.         
   */                                                                 
  result = IMFS_eval_path(                                            
a000dc04:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000dc08:	e5966050 	ldr	r6, [r6, #80]	; 0x50                          <== NOT EXECUTED
a000dc0c:	e0866003 	add	r6, r6, r3                                    <== NOT EXECUTED
a000dc10:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000dc14:	eb00111b 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a000dc18:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000dc1c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000dc20:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000dc24:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000dc28:	ebffff4b 	bl	a000d95c <IMFS_eval_path>                      <== NOT EXECUTED
a000dc2c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    strlen( &jnode->info.sym_link.name[i] ),                          
    flags,                                                            
    node                                                              
  );                                                                  
                                                                      
  IMFS_Set_handlers( node );                                          
a000dc30:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000dc34:	ebffff00 	bl	a000d83c <IMFS_Set_handlers>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
  if ( !IMFS_evaluate_permission( node, flags ) )                     
a000dc38:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000dc3c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000dc40:	ebffff22 	bl	a000d8d0 <IMFS_evaluate_permission>            <== NOT EXECUTED
a000dc44:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000dc48:	0a000002 	beq	a000dc58 <IMFS_evaluate_sym_link+0x80>        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EACCES );                   
                                                                      
  return result;                                                      
}                                                                     
a000dc4c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000dc50:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000dc54:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify we have the correct permissions for this node.            
   */                                                                 
  if ( !IMFS_evaluate_permission( node, flags ) )                     
    rtems_set_errno_and_return_minus_one( EACCES );                   
a000dc58:	eb000d20 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000dc5c:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
a000dc60:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000dc64:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000dc68:	eafffff7 	b	a000dc4c <IMFS_evaluate_sym_link+0x74>          <== NOT EXECUTED
                                                                      

a0010b24 <IMFS_fchmod>: int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) {
a0010b24:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t  *jnode;                                               
#if defined(RTEMS_POSIX_API)                                          
  uid_t          st_uid;                                              
#endif                                                                
                                                                      
  jnode = loc->node_access;                                           
a0010b28:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
a0010b2c:	e1a02a01 	lsl	r2, r1, #20                                   <== NOT EXECUTED
                                                                      
int IMFS_fchmod(                                                      
  rtems_filesystem_location_info_t *loc,                              
  mode_t                            mode                              
)                                                                     
{                                                                     
a0010b30:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
a0010b34:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
                                                                      
  IMFS_update_ctime( jnode );                                         
a0010b38:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0010b3c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Change only the RWX permissions on the jnode to mode.            
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
a0010b40:	e3c33eff 	bic	r3, r3, #4080	; 0xff0                         <== NOT EXECUTED
a0010b44:	e3c3300f 	bic	r3, r3, #15                                   <== NOT EXECUTED
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
a0010b48:	e1833a22 	orr	r3, r3, r2, lsr #20                           <== NOT EXECUTED
a0010b4c:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
  IMFS_update_ctime( jnode );                                         
a0010b50:	ebffd63c 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a0010b54:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0010b58:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
  jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
                                                                      
  IMFS_update_ctime( jnode );                                         
a0010b5c:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0010b60:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0010b64:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0010b68 <IMFS_fdatasync>: int IMFS_fdatasync( rtems_libio_t *iop ) { return 0; }
a0010b68:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010b6c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007038 <IMFS_fifo_close>: } int IMFS_fifo_close( rtems_libio_t *iop ) {
a0007038:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  int err = 0;                                                        
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
a000703c:	e5905018 	ldr	r5, [r0, #24]                                 <== NOT EXECUTED
}                                                                     
                                                                      
int IMFS_fifo_close(                                                  
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a0007040:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int err = 0;                                                        
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  pipe_release(&JNODE2PIPE(jnode), iop);                              
a0007044:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0007048:	e2850050 	add	r0, r5, #80	; 0x50                            <== NOT EXECUTED
a000704c:	eb00252b 	bl	a0010500 <pipe_release>                        <== NOT EXECUTED
                                                                      
  iop->flags &= ~LIBIO_FLAGS_OPEN;                                    
a0007050:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
  IMFS_check_node_remove(jnode);                                      
a0007054:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  int err = 0;                                                        
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  pipe_release(&JNODE2PIPE(jnode), iop);                              
                                                                      
  iop->flags &= ~LIBIO_FLAGS_OPEN;                                    
a0007058:	e3c33c01 	bic	r3, r3, #256	; 0x100                          <== NOT EXECUTED
a000705c:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
  IMFS_check_node_remove(jnode);                                      
a0007060:	eb00018c 	bl	a0007698 <IMFS_check_node_remove>              <== NOT EXECUTED
                                                                      
  IMFS_FIFO_RETURN(err);                                              
}                                                                     
a0007064:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007068:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0006efc <IMFS_fifo_ioctl>: int IMFS_fifo_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) {
a0006efc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  int err;                                                            
                                                                      
  if (command == FIONBIO) {                                           
a0006f00:	e59f0070 	ldr	r0, [pc, #112]	; a0006f78 <IMFS_fifo_ioctl+0x7c><== NOT EXECUTED
int IMFS_fifo_ioctl(                                                  
  rtems_libio_t *iop,                                                 
  uint32_t       command,                                             
  void          *buffer                                               
)                                                                     
{                                                                     
a0006f04:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int err;                                                            
                                                                      
  if (command == FIONBIO) {                                           
a0006f08:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
a0006f0c:	0a000007 	beq	a0006f30 <IMFS_fifo_ioctl+0x34>               <== NOT EXECUTED
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
      return 0;                                                       
    }                                                                 
  }                                                                   
  else                                                                
    err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);          
a0006f10:	e5930018 	ldr	r0, [r3, #24]                                 <== NOT EXECUTED
a0006f14:	e5900050 	ldr	r0, [r0, #80]	; 0x50                          <== NOT EXECUTED
a0006f18:	eb0027ac 	bl	a0010dd0 <pipe_ioctl>                          <== NOT EXECUTED
                                                                      
  IMFS_FIFO_RETURN(err);                                              
a0006f1c:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
a0006f20:	b2624000 	rsblt	r4, r2, #0                                  <== NOT EXECUTED
a0006f24:	ba00000f 	blt	a0006f68 <IMFS_fifo_ioctl+0x6c>               <== NOT EXECUTED
}                                                                     
a0006f28:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0006f2c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  int err;                                                            
                                                                      
  if (command == FIONBIO) {                                           
    if (buffer == NULL)                                               
a0006f30:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0006f34:	0a00000a 	beq	a0006f64 <IMFS_fifo_ioctl+0x68>               <== NOT EXECUTED
      err = -EFAULT;                                                  
    else {                                                            
      if (*(int *)buffer)                                             
a0006f38:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
a0006f3c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        iop->flags |= LIBIO_FLAGS_NO_DELAY;                           
a0006f40:	15931014 	ldrne	r1, [r3, #20]                               <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
a0006f44:	05931014 	ldreq	r1, [r3, #20]                               <== NOT EXECUTED
      return 0;                                                       
a0006f48:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
  if (command == FIONBIO) {                                           
    if (buffer == NULL)                                               
      err = -EFAULT;                                                  
    else {                                                            
      if (*(int *)buffer)                                             
        iop->flags |= LIBIO_FLAGS_NO_DELAY;                           
a0006f4c:	13811001 	orrne	r1, r1, #1                                  <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
a0006f50:	03c11001 	biceq	r1, r1, #1                                  <== NOT EXECUTED
  if (command == FIONBIO) {                                           
    if (buffer == NULL)                                               
      err = -EFAULT;                                                  
    else {                                                            
      if (*(int *)buffer)                                             
        iop->flags |= LIBIO_FLAGS_NO_DELAY;                           
a0006f54:	15831014 	strne	r1, [r3, #20]                               <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                          
a0006f58:	05831014 	streq	r1, [r3, #20]                               <== NOT EXECUTED
  }                                                                   
  else                                                                
    err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);          
                                                                      
  IMFS_FIFO_RETURN(err);                                              
}                                                                     
a0006f5c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0006f60:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  int err;                                                            
                                                                      
  if (command == FIONBIO) {                                           
    if (buffer == NULL)                                               
a0006f64:	e3a0400e 	mov	r4, #14                                       <== NOT EXECUTED
    }                                                                 
  }                                                                   
  else                                                                
    err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);          
                                                                      
  IMFS_FIFO_RETURN(err);                                              
a0006f68:	eb003007 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0006f6c:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a0006f70:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
a0006f74:	eaffffeb 	b	a0006f28 <IMFS_fifo_ioctl+0x2c>                 <== NOT EXECUTED
                                                                      

a0006e9c <IMFS_fifo_lseek>: rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) {
a0006e9c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
a0006ea0:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
rtems_off64_t IMFS_fifo_lseek(                                        
  rtems_libio_t *iop,                                                 
  rtems_off64_t  offset,                                              
  int            whence                                               
)                                                                     
{                                                                     
a0006ea4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
a0006ea8:	e59cc050 	ldr	ip, [ip, #80]	; 0x50                          <== NOT EXECUTED
a0006eac:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
a0006eb0:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
a0006eb4:	eb0027e0 	bl	a0010e3c <pipe_lseek>                          <== NOT EXECUTED
a0006eb8:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0006ebc:	e1a03fc2 	asr	r3, r2, #31                                   <== NOT EXECUTED
  IMFS_FIFO_RETURN(err);                                              
a0006ec0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  rtems_off64_t  offset,                                              
  int            whence                                               
)                                                                     
{                                                                     
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
a0006ec4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  IMFS_FIFO_RETURN(err);                                              
a0006ec8:	a1a04003 	movge	r4, r3                                      <== NOT EXECUTED
a0006ecc:	a1a03002 	movge	r3, r2                                      <== NOT EXECUTED
a0006ed0:	ba000003 	blt	a0006ee4 <IMFS_fifo_lseek+0x48>               <== NOT EXECUTED
}                                                                     
a0006ed4:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0006ed8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006edc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0006ee0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  rtems_off64_t  offset,                                              
  int            whence                                               
)                                                                     
{                                                                     
  off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);       
  IMFS_FIFO_RETURN(err);                                              
a0006ee4:	eb003028 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0006ee8:	e2644000 	rsb	r4, r4, #0                                    <== NOT EXECUTED
a0006eec:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
a0006ef0:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a0006ef4:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a0006ef8:	eafffff5 	b	a0006ed4 <IMFS_fifo_lseek+0x38>                 <== NOT EXECUTED
                                                                      

a000706c <IMFS_fifo_open>: uint32_t mode ) { IMFS_jnode_t *jnode = iop->pathinfo.node_access; int err = fifo_open(&JNODE2PIPE(jnode), iop);
a000706c:	e5903018 	ldr	r3, [r0, #24]                                 <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  const char    *pathname,                                            
  uint32_t       flag,                                                
  uint32_t       mode                                                 
)                                                                     
{                                                                     
a0007070:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a0007074:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  int err = fifo_open(&JNODE2PIPE(jnode), iop);                       
a0007078:	e2830050 	add	r0, r3, #80	; 0x50                            <== NOT EXECUTED
a000707c:	eb002555 	bl	a00105d8 <fifo_open>                           <== NOT EXECUTED
  IMFS_FIFO_RETURN(err);                                              
a0007080:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0007084:	ba000001 	blt	a0007090 <IMFS_fifo_open+0x24>                <== NOT EXECUTED
}                                                                     
a0007088:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000708c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  int err = fifo_open(&JNODE2PIPE(jnode), iop);                       
  IMFS_FIFO_RETURN(err);                                              
a0007090:	eb002fbd 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0007094:	e2644000 	rsb	r4, r4, #0                                    <== NOT EXECUTED
a0007098:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
a000709c:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a00070a0:	eafffff8 	b	a0007088 <IMFS_fifo_open+0x1c>                  <== NOT EXECUTED
                                                                      

a0006fdc <IMFS_fifo_read>: ssize_t IMFS_fifo_read( rtems_libio_t *iop, void *buffer, size_t count ) {
a0006fdc:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
a0006fe0:	e5904018 	ldr	r4, [r0, #24]                                 <== NOT EXECUTED
ssize_t IMFS_fifo_read(                                               
  rtems_libio_t *iop,                                                 
  void          *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a0006fe4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a0006fe8:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);         
a0006fec:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0006ff0:	eb002689 	bl	a0010a1c <pipe_read>                           <== NOT EXECUTED
  if (err > 0)                                                        
a0006ff4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a0006ff8:	da000007 	ble	a000701c <IMFS_fifo_read+0x40>                <== NOT EXECUTED
    IMFS_update_atime(jnode);                                         
a0006ffc:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0007000:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0007004:	eb00040a 	bl	a0008034 <gettimeofday>                        <== NOT EXECUTED
a0007008:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000700c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007010:	e5843040 	str	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  IMFS_FIFO_RETURN(err);                                              
}                                                                     
a0007014:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0007018:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);         
  if (err > 0)                                                        
    IMFS_update_atime(jnode);                                         
                                                                      
  IMFS_FIFO_RETURN(err);                                              
a000701c:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
a0007020:	0afffffb 	beq	a0007014 <IMFS_fifo_read+0x38>                <== NOT EXECUTED
a0007024:	eb002fd8 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0007028:	e2655000 	rsb	r5, r5, #0                                    <== NOT EXECUTED
a000702c:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
a0007030:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007034:	eafffff6 	b	a0007014 <IMFS_fifo_read+0x38>                  <== NOT EXECUTED
                                                                      

a0006f7c <IMFS_fifo_write>: ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
a0006f7c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
a0006f80:	e5904018 	ldr	r4, [r0, #24]                                 <== NOT EXECUTED
ssize_t IMFS_fifo_write(                                              
  rtems_libio_t *iop,                                                 
  const void    *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a0006f84:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a0006f88:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
                                                                      
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
a0006f8c:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0006f90:	eb00270d 	bl	a0010bcc <pipe_write>                          <== NOT EXECUTED
  if (err > 0) {                                                      
a0006f94:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a0006f98:	da000008 	ble	a0006fc0 <IMFS_fifo_write+0x44>               <== NOT EXECUTED
    IMFS_mtime_ctime_update(jnode);                                   
a0006f9c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0006fa0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0006fa4:	eb000422 	bl	a0008034 <gettimeofday>                        <== NOT EXECUTED
a0006fa8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0006fac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0006fb0:	e5843044 	str	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
a0006fb4:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
}                                                                     
a0006fb8:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0006fbc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
  if (err > 0) {                                                      
    IMFS_mtime_ctime_update(jnode);                                   
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
a0006fc0:	01a00005 	moveq	r0, r5                                      <== NOT EXECUTED
a0006fc4:	0afffffb 	beq	a0006fb8 <IMFS_fifo_write+0x3c>               <== NOT EXECUTED
a0006fc8:	eb002fef 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0006fcc:	e2655000 	rsb	r5, r5, #0                                    <== NOT EXECUTED
a0006fd0:	e5805000 	str	r5, [r0]                                      <== NOT EXECUTED
a0006fd4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006fd8:	eafffff6 	b	a0006fb8 <IMFS_fifo_write+0x3c>                 <== NOT EXECUTED
                                                                      

a000e098 <IMFS_find_match_in_dir>: IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) {
a000e098:	e92d4070 	push	{r4, r5, r6, lr}                             
a000e09c:	e1a05001 	mov	r5, r1                                        
a000e0a0:	e1a04000 	mov	r4, r0                                        
                                                                      
  /*                                                                  
   *  Check for "." and ".."                                          
   */                                                                 
                                                                      
  if ( !strcmp( name, dotname ) )                                     
a000e0a4:	e59f1068 	ldr	r1, [pc, #104]	; a000e114 <IMFS_find_match_in_dir+0x7c>
a000e0a8:	e1a00005 	mov	r0, r5                                        
a000e0ac:	eb000f19 	bl	a0011d18 <strcmp>                              
a000e0b0:	e3500000 	cmp	r0, #0                                        
a000e0b4:	0a000005 	beq	a000e0d0 <IMFS_find_match_in_dir+0x38>        
    return directory;                                                 
                                                                      
  if ( !strcmp( name, dotdotname ) )                                  
a000e0b8:	e1a00005 	mov	r0, r5                                        
a000e0bc:	e59f1054 	ldr	r1, [pc, #84]	; a000e118 <IMFS_find_match_in_dir+0x80>
a000e0c0:	eb000f14 	bl	a0011d18 <strcmp>                              
a000e0c4:	e3500000 	cmp	r0, #0                                        
    return directory->Parent;                                         
a000e0c8:	05944008 	ldreq	r4, [r4, #8]                                
   */                                                                 
                                                                      
  if ( !strcmp( name, dotname ) )                                     
    return directory;                                                 
                                                                      
  if ( !strcmp( name, dotdotname ) )                                  
a000e0cc:	1a000001 	bne	a000e0d8 <IMFS_find_match_in_dir+0x40>        
    if ( !strcmp( name, the_jnode->name ) )                           
      return the_jnode;                                               
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000e0d0:	e1a00004 	mov	r0, r4                                        
a000e0d4:	e8bd8070 	pop	{r4, r5, r6, pc}                              
a000e0d8:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  Chain_Control *the_chain,                                           
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Tail(the_chain));                        
a000e0dc:	e2846054 	add	r6, r4, #84	; 0x54                            
  if ( !strcmp( name, dotdotname ) )                                  
    return directory->Parent;                                         
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
a000e0e0:	e1530006 	cmp	r3, r6                                        
a000e0e4:	0a000008 	beq	a000e10c <IMFS_find_match_in_dir+0x74>        
a000e0e8:	e1a04003 	mov	r4, r3                                        
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    if ( !strcmp( name, the_jnode->name ) )                           
a000e0ec:	e284100c 	add	r1, r4, #12                                   
a000e0f0:	e1a00005 	mov	r0, r5                                        
a000e0f4:	eb000f07 	bl	a0011d18 <strcmp>                              
a000e0f8:	e3500000 	cmp	r0, #0                                        
a000e0fc:	0afffff3 	beq	a000e0d0 <IMFS_find_match_in_dir+0x38>        
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
        !rtems_chain_is_tail( the_chain, the_node );                  
        the_node = the_node->next ) {                                 
a000e100:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
  if ( !strcmp( name, dotdotname ) )                                  
    return directory->Parent;                                         
                                                                      
  the_chain = &directory->info.directory.Entries;                     
                                                                      
  for ( the_node = rtems_chain_first( the_chain );                    
a000e104:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
a000e108:	1afffff7 	bne	a000e0ec <IMFS_find_match_in_dir+0x54>        <== NOT EXECUTED
                                                                      
    if ( !strcmp( name, the_jnode->name ) )                           
      return the_jnode;                                               
  }                                                                   
                                                                      
  return 0;                                                           
a000e10c:	e3a04000 	mov	r4, #0                                        
a000e110:	eaffffee 	b	a000e0d0 <IMFS_find_match_in_dir+0x38>          
                                                                      

a000dfc8 <IMFS_fsunmount>: ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) {
a000dfc8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   /*                                                                 
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
a000dfcc:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
a000dfd0:	e5bc401c 	ldr	r4, [ip, #28]!                                <== NOT EXECUTED
    ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
                                                                      
int IMFS_fsunmount(                                                   
  rtems_filesystem_mount_table_entry_t *temp_mt_entry                 
)                                                                     
{                                                                     
a000dfd4:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
   loc = temp_mt_entry->mt_fs_root;                                   
a000dfd8:	e1a0600d 	mov	r6, sp                                        <== NOT EXECUTED
    ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
                                                                      
int IMFS_fsunmount(                                                   
  rtems_filesystem_mount_table_entry_t *temp_mt_entry                 
)                                                                     
{                                                                     
a000dfdc:	e1a0e000 	mov	lr, r0                                        <== NOT EXECUTED
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
   loc = temp_mt_entry->mt_fs_root;                                   
a000dfe0:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000dfe4:	e8a6000f 	stmia	r6!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000dfe8:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
a000dfec:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
   loc = temp_mt_entry->mt_fs_root;                                   
a000dff0:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
a000dff4:	e58e101c 	str	r1, [lr, #28]                                 <== NOT EXECUTED
    * Traverse tree that starts at the mt_fs_root and deallocate memory
    * associated memory space                                         
    */                                                                
                                                                      
   jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;     
   loc = temp_mt_entry->mt_fs_root;                                   
a000dff8:	e5862000 	str	r2, [r6]                                      <== NOT EXECUTED
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
a000dffc:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root.node_access = NULL;                      
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
a000e000:	e5946008 	ldr	r6, [r4, #8]                                  <== NOT EXECUTED
     loc.node_access = (void *)jnode;                                 
a000e004:	e58d4000 	str	r4, [sp]                                      <== NOT EXECUTED
     IMFS_Set_handlers( &loc );                                       
a000e008:	ebfffe0b 	bl	a000d83c <IMFS_Set_handlers>                   <== NOT EXECUTED
                                                                      
     if ( jnode->type != IMFS_DIRECTORY ) {                           
a000e00c:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a000e010:	e2842054 	add	r2, r4, #84	; 0x54                            <== NOT EXECUTED
a000e014:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000e018:	1a000010 	bne	a000e060 <IMFS_fsunmount+0x98>                <== NOT EXECUTED
        result = IMFS_unlink( NULL, &loc );                           
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
     } else if ( jnode_has_no_children( jnode ) ) {                   
a000e01c:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000e020:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000e024:	0a000014 	beq	a000e07c <IMFS_fsunmount+0xb4>                <== NOT EXECUTED
        result = IMFS_unlink( NULL, &loc );                           
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
a000e028:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000e02c:	0a000008 	beq	a000e054 <IMFS_fsunmount+0x8c>                <== NOT EXECUTED
       if ( jnode->type == IMFS_DIRECTORY ) {                         
a000e030:	e594304c 	ldr	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000e034:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000e038:	1affffef 	bne	a000dffc <IMFS_fsunmount+0x34>                <== NOT EXECUTED
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
                                                                      
   return 0;                                                          
}                                                                     
a000e03c:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000e040:	e2842054 	add	r2, r4, #84	; 0x54                            <== NOT EXECUTED
          return -1;                                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
       if ( jnode->type == IMFS_DIRECTORY ) {                         
         if ( jnode_has_children( jnode ) )                           
a000e044:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000e048:	0affffeb 	beq	a000dffc <IMFS_fsunmount+0x34>                <== NOT EXECUTED
           jnode = jnode_get_first_child( jnode );                    
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
a000e04c:	e2534000 	subs	r4, r3, #0                                   <== NOT EXECUTED
a000e050:	1affffe9 	bne	a000dffc <IMFS_fsunmount+0x34>                <== NOT EXECUTED
                                                                      
   return 0;                                                          
a000e054:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a000e058:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a000e05c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( jnode->type != IMFS_DIRECTORY ) {                           
        result = IMFS_unlink( NULL, &loc );                           
a000e060:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000e064:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000e068:	ebffdf84 	bl	a0005e80 <IMFS_unlink>                         <== NOT EXECUTED
        if (result != 0)                                              
a000e06c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e070:	1a000006 	bne	a000e090 <IMFS_fsunmount+0xc8>                <== NOT EXECUTED
        jnode = next;                                                 
     } else if ( jnode_has_no_children( jnode ) ) {                   
        result = IMFS_unlink( NULL, &loc );                           
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
a000e074:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
a000e078:	eaffffea 	b	a000e028 <IMFS_fsunmount+0x60>                  <== NOT EXECUTED
        result = IMFS_unlink( NULL, &loc );                           
        if (result != 0)                                              
          return -1;                                                  
        jnode = next;                                                 
     } else if ( jnode_has_no_children( jnode ) ) {                   
        result = IMFS_unlink( NULL, &loc );                           
a000e07c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000e080:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000e084:	ebffdf7d 	bl	a0005e80 <IMFS_unlink>                         <== NOT EXECUTED
        if (result != 0)                                              
a000e088:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e08c:	0afffff8 	beq	a000e074 <IMFS_fsunmount+0xac>                <== NOT EXECUTED
          return -1;                                                  
a000e090:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000e094:	eaffffef 	b	a000e058 <IMFS_fsunmount+0x90>                  <== NOT EXECUTED
                                                                      

a000e11c <IMFS_get_token>: const char *path, int pathlen, char *token, int *token_len ) {
a000e11c:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
a000e120:	e1a05001 	mov	r5, r1                                        
a000e124:	e1a04002 	mov	r4, r2                                        
a000e128:	e1a0a003 	mov	sl, r3                                        
  register char c;                                                    
                                                                      
  /*                                                                  
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
a000e12c:	e5d07000 	ldrb	r7, [r0]                                     
a000e130:	e1a08000 	mov	r8, r0                                        
  int               pathlen,                                          
  char             *token,                                            
  int              *token_len                                         
)                                                                     
{                                                                     
  register int i = 0;                                                 
a000e134:	e3a06000 	mov	r6, #0                                        
                                                                      
  /*                                                                  
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
  while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
a000e138:	ea000006 	b	a000e158 <IMFS_get_token+0x3c>                  
a000e13c:	e1560005 	cmp	r6, r5                                        
a000e140:	aa000008 	bge	a000e168 <IMFS_get_token+0x4c>                
                                                                      
     token[i] = c;                                                    
                                                                      
     if ( i == IMFS_NAME_MAX )                                        
a000e144:	e3560020 	cmp	r6, #32                                       
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
  while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
                                                                      
     token[i] = c;                                                    
a000e148:	e7c47006 	strb	r7, [r4, r6]                                 
                                                                      
     if ( i == IMFS_NAME_MAX )                                        
a000e14c:	0a00001b 	beq	a000e1c0 <IMFS_get_token+0xa4>                
       return IMFS_INVALID_TOKEN;                                     
                                                                      
     if ( !IMFS_is_valid_name_char(c) )                               
       type = IMFS_INVALID_TOKEN;                                     
                                                                      
     c = path [++i];                                                  
a000e150:	e5f87001 	ldrb	r7, [r8, #1]!                                
a000e154:	e2866001 	add	r6, r6, #1                                    
                                                                      
  /*                                                                  
   *  Copy a name into token.  (Remember NULL is a token.)            
   */                                                                 
  c = path[i];                                                        
  while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
a000e158:	e1a00007 	mov	r0, r7                                        
a000e15c:	ebffe452 	bl	a00072ac <rtems_filesystem_is_separator>       
a000e160:	e3500000 	cmp	r0, #0                                        
a000e164:	0afffff4 	beq	a000e13c <IMFS_get_token+0x20>                
                                                                      
  /*                                                                  
   *  Copy a seperator into token.                                    
   */                                                                 
                                                                      
  if ( i == 0 ) {                                                     
a000e168:	e3560000 	cmp	r6, #0                                        
a000e16c:	1a000006 	bne	a000e18c <IMFS_get_token+0x70>                
    token[i] = c;                                                     
                                                                      
    if ( (token[i] != '\0') && pathlen ) {                            
a000e170:	e3570000 	cmp	r7, #0                                        
a000e174:	13550000 	cmpne	r5, #0                                      
      i++;                                                            
      type = IMFS_CURRENT_DIR;                                        
a000e178:	13a06001 	movne	r6, #1                                      
  /*                                                                  
   *  Copy a seperator into token.                                    
   */                                                                 
                                                                      
  if ( i == 0 ) {                                                     
    token[i] = c;                                                     
a000e17c:	e5c47000 	strb	r7, [r4]                                     
                                                                      
    if ( (token[i] != '\0') && pathlen ) {                            
      i++;                                                            
a000e180:	e1a00006 	mov	r0, r6                                        
                                                                      
  /*                                                                  
   *  Set token_len to the number of characters copied.               
   */                                                                 
                                                                      
  *token_len = i;                                                     
a000e184:	e58a6000 	str	r6, [sl]                                      
a000e188:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
      i++;                                                            
      type = IMFS_CURRENT_DIR;                                        
    } else {                                                          
      type = IMFS_NO_MORE_PATH;                                       
    }                                                                 
  } else if (token[ i-1 ] != '\0') {                                  
a000e18c:	e0843006 	add	r3, r4, r6                                    
a000e190:	e5533001 	ldrb	r3, [r3, #-1]                                
   *  If we copied something that was not a seperator see if          
   *  it was a special name.                                          
   */                                                                 
                                                                      
  if ( type == IMFS_NAME ) {                                          
    if ( strcmp( token, "..") == 0 )                                  
a000e194:	e1a00004 	mov	r0, r4                                        
a000e198:	e59f1044 	ldr	r1, [pc, #68]	; a000e1e4 <IMFS_get_token+0xc8>
      i++;                                                            
      type = IMFS_CURRENT_DIR;                                        
    } else {                                                          
      type = IMFS_NO_MORE_PATH;                                       
    }                                                                 
  } else if (token[ i-1 ] != '\0') {                                  
a000e19c:	e3530000 	cmp	r3, #0                                        
    token[i] = '\0';                                                  
a000e1a0:	13a03000 	movne	r3, #0                                      
a000e1a4:	17c43006 	strbne	r3, [r4, r6]                               
                                                                      
  /*                                                                  
   *  Set token_len to the number of characters copied.               
   */                                                                 
                                                                      
  *token_len = i;                                                     
a000e1a8:	e58a6000 	str	r6, [sl]                                      
   *  If we copied something that was not a seperator see if          
   *  it was a special name.                                          
   */                                                                 
                                                                      
  if ( type == IMFS_NAME ) {                                          
    if ( strcmp( token, "..") == 0 )                                  
a000e1ac:	eb000ed9 	bl	a0011d18 <strcmp>                              
a000e1b0:	e3500000 	cmp	r0, #0                                        
a000e1b4:	1a000003 	bne	a000e1c8 <IMFS_get_token+0xac>                
      type = IMFS_UP_DIR;                                             
a000e1b8:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
    else if ( strcmp( token, "." ) == 0 )                             
      type = IMFS_CURRENT_DIR;                                        
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
a000e1bc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
                                                                      
     token[i] = c;                                                    
                                                                      
     if ( i == IMFS_NAME_MAX )                                        
       return IMFS_INVALID_TOKEN;                                     
a000e1c0:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
a000e1c4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( type == IMFS_NAME ) {                                          
    if ( strcmp( token, "..") == 0 )                                  
      type = IMFS_UP_DIR;                                             
    else if ( strcmp( token, "." ) == 0 )                             
a000e1c8:	e1a00004 	mov	r0, r4                                        
a000e1cc:	e59f1014 	ldr	r1, [pc, #20]	; a000e1e8 <IMFS_get_token+0xcc>
a000e1d0:	eb000ed0 	bl	a0011d18 <strcmp>                              
a000e1d4:	e3500000 	cmp	r0, #0                                        
a000e1d8:	03a00001 	moveq	r0, #1                                      
a000e1dc:	13a00003 	movne	r0, #3                                      
a000e1e0:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

a0005a64 <IMFS_initialize_support>: const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *memfile_handlers, const rtems_filesystem_file_handlers_r *directory_handlers, const rtems_filesystem_file_handlers_r *fifo_handlers ) {
a0005a64:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
a0005a68:	e1a08001 	mov	r8, r1                                        
  IMFS_jnode_t                          *jnode;                       
                                                                      
  /*                                                                  
   * determine/check value for imfs_memfile_bytes_per_block           
   */                                                                 
  IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,       
a0005a6c:	e59f10e0 	ldr	r1, [pc, #224]	; a0005b54 <IMFS_initialize_support+0xf0>
   const rtems_filesystem_operations_table    *op_table,              
   const rtems_filesystem_file_handlers_r     *memfile_handlers,      
   const rtems_filesystem_file_handlers_r     *directory_handlers,    
   const rtems_filesystem_file_handlers_r     *fifo_handlers          
)                                                                     
{                                                                     
a0005a70:	e1a04000 	mov	r4, r0                                        
a0005a74:	e1a0a002 	mov	sl, r2                                        
  IMFS_jnode_t                          *jnode;                       
                                                                      
  /*                                                                  
   * determine/check value for imfs_memfile_bytes_per_block           
   */                                                                 
  IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,       
a0005a78:	e5911000 	ldr	r1, [r1]                                      
   const rtems_filesystem_operations_table    *op_table,              
   const rtems_filesystem_file_handlers_r     *memfile_handlers,      
   const rtems_filesystem_file_handlers_r     *directory_handlers,    
   const rtems_filesystem_file_handlers_r     *fifo_handlers          
)                                                                     
{                                                                     
a0005a7c:	e1a07003 	mov	r7, r3                                        
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
    if (bit_mask == requested_bytes_per_block) {                      
a0005a80:	e3510010 	cmp	r1, #16                                       
a0005a84:	0a00000a 	beq	a0005ab4 <IMFS_initialize_support+0x50>       
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
a0005a88:	e351000f 	cmp	r1, #15                                       
a0005a8c:	c3a02005 	movgt	r2, #5                                      
a0005a90:	c3a03020 	movgt	r3, #32                                     
a0005a94:	da000005 	ble	a0005ab0 <IMFS_initialize_support+0x4c>       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
    if (bit_mask == requested_bytes_per_block) {                      
a0005a98:	e1510003 	cmp	r1, r3                                        
a0005a9c:	0a000004 	beq	a0005ab4 <IMFS_initialize_support+0x50>       
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
a0005aa0:	ba000002 	blt	a0005ab0 <IMFS_initialize_support+0x4c>       
  int bit_mask;                                                       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
a0005aa4:	e2522001 	subs	r2, r2, #1                                   
a0005aa8:	e1a03083 	lsl	r3, r3, #1                                    
a0005aac:	1afffff9 	bne	a0005a98 <IMFS_initialize_support+0x34>       
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
			   ? requested_bytes_per_block                                     
			   : default_bytes_per_block);                                     
a0005ab0:	e3a01080 	mov	r1, #128	; 0x80                               
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
a0005ab4:	e59f509c 	ldr	r5, [pc, #156]	; a0005b58 <IMFS_initialize_support+0xf4>
a0005ab8:	e5851000 	str	r1, [r5]                                      
  /*                                                                  
   *  Create the root node                                            
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).            
   */                                                                 
  temp_mt_entry->mt_fs_root.node_access      = IMFS_create_root_node();
a0005abc:	eb001f4e 	bl	a000d7fc <IMFS_create_root_node>               
  temp_mt_entry->mt_fs_root.handlers         = directory_handlers;    
  temp_mt_entry->mt_fs_root.ops              = op_table;              
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
a0005ac0:	e59fe094 	ldr	lr, [pc, #148]	; a0005b5c <IMFS_initialize_support+0xf8>
a0005ac4:	e284c038 	add	ip, r4, #56	; 0x38                            
  /*                                                                  
   *  Create the root node                                            
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).            
   */                                                                 
  temp_mt_entry->mt_fs_root.node_access      = IMFS_create_root_node();
a0005ac8:	e584001c 	str	r0, [r4, #28]                                 
a0005acc:	e1a06000 	mov	r6, r0                                        
  temp_mt_entry->mt_fs_root.handlers         = directory_handlers;    
  temp_mt_entry->mt_fs_root.ops              = op_table;              
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
a0005ad0:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
a0005ad4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
a0005ad8:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
a0005adc:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
a0005ae0:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          
   *  Create the root node                                            
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).            
   */                                                                 
  temp_mt_entry->mt_fs_root.node_access      = IMFS_create_root_node();
  temp_mt_entry->mt_fs_root.handlers         = directory_handlers;    
a0005ae4:	e5847024 	str	r7, [r4, #36]	; 0x24                          
  temp_mt_entry->mt_fs_root.ops              = op_table;              
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
a0005ae8:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).            
   */                                                                 
  temp_mt_entry->mt_fs_root.node_access      = IMFS_create_root_node();
  temp_mt_entry->mt_fs_root.handlers         = directory_handlers;    
  temp_mt_entry->mt_fs_root.ops              = op_table;              
a0005aec:	e5848028 	str	r8, [r4, #40]	; 0x28                          
  temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
                                                                      
  /*                                                                  
   * Create custom file system data.                                  
   */                                                                 
  fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );                    
a0005af0:	e3a00001 	mov	r0, #1                                        
a0005af4:	e3a01014 	mov	r1, #20                                       
a0005af8:	eb0001af 	bl	a00061bc <calloc>                              
  if ( !fs_info ) {                                                   
a0005afc:	e3500000 	cmp	r0, #0                                        
a0005b00:	0a00000c 	beq	a0005b38 <IMFS_initialize_support+0xd4>       
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
a0005b04:	e5952004 	ldr	r2, [r5, #4]                                  
  fs_info->ino_count             = 1;                                 
a0005b08:	e3a03001 	mov	r3, #1                                        
  fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );                    
  if ( !fs_info ) {                                                   
    free(temp_mt_entry->mt_fs_root.node_access);                      
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
  }                                                                   
  temp_mt_entry->fs_info = fs_info;                                   
a0005b0c:	e5840034 	str	r0, [r4, #52]	; 0x34                          
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
a0005b10:	e0821003 	add	r1, r2, r3                                    
a0005b14:	e5802000 	str	r2, [r0]                                      
  fs_info->ino_count             = 1;                                 
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
  fs_info->fifo_handlers         = fifo_handlers;                     
a0005b18:	e59d201c 	ldr	r2, [sp, #28]                                 
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
  fs_info->ino_count             = 1;                                 
a0005b1c:	e9800408 	stmib	r0, {r3, sl}                                
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
a0005b20:	e580700c 	str	r7, [r0, #12]                                 
  fs_info->fifo_handlers         = fifo_handlers;                     
a0005b24:	e5802010 	str	r2, [r0, #16]                                 
                                                                      
  /*                                                                  
   * Set st_ino for the root to 1.                                    
   */                                                                 
                                                                      
  fs_info->instance              = imfs_instance++;                   
a0005b28:	e5851004 	str	r1, [r5, #4]                                  
  fs_info->memfile_handlers      = memfile_handlers;                  
  fs_info->directory_handlers    = directory_handlers;                
  fs_info->fifo_handlers         = fifo_handlers;                     
                                                                      
  jnode = temp_mt_entry->mt_fs_root.node_access;                      
  jnode->st_ino = fs_info->ino_count;                                 
a0005b2c:	e5863038 	str	r3, [r6, #56]	; 0x38                          
                                                                      
  return 0;                                                           
a0005b30:	e3a00000 	mov	r0, #0                                        
}                                                                     
a0005b34:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
  /*                                                                  
   * Create custom file system data.                                  
   */                                                                 
  fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );                    
  if ( !fs_info ) {                                                   
    free(temp_mt_entry->mt_fs_root.node_access);                      
a0005b38:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005b3c:	eb00020c 	bl	a0006374 <free>                                <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
a0005b40:	eb002d66 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005b44:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0005b48:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005b4c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005b50:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a0005b60 <IMFS_link>: int i; /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access;
a0005b60:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
int IMFS_link(                                                        
  rtems_filesystem_location_info_t  *to_loc,      /* IN */            
  rtems_filesystem_location_info_t  *parent_loc,  /* IN */            
  const char                        *token        /* IN */            
)                                                                     
{                                                                     
a0005b64:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0005b68:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
a0005b6c:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
int IMFS_link(                                                        
  rtems_filesystem_location_info_t  *to_loc,      /* IN */            
  rtems_filesystem_location_info_t  *parent_loc,  /* IN */            
  const char                        *token        /* IN */            
)                                                                     
{                                                                     
a0005b70:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0005b74:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
a0005b78:	e3520007 	cmp	r2, #7                                        <== NOT EXECUTED
  int                i;                                               
                                                                      
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
a0005b7c:	e58d3028 	str	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
a0005b80:	8a00001e 	bhi	a0005c00 <IMFS_link+0xa0>                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EMLINK );                   
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( token, strlen( token ), new_name, &i );             
a0005b84:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005b88:	eb00313e 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a0005b8c:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0005b90:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0005b94:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005b98:	e28d3044 	add	r3, sp, #68	; 0x44                            <== NOT EXECUTED
a0005b9c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005ba0:	eb00215d 	bl	a000e11c <IMFS_get_token>                      <== NOT EXECUTED
   *        was ONLY passed a NULL when we created the root node.  We 
   *        added a new IMFS_create_root_node() so this path no longer
   *        existed.  The result was simpler code which should not have
   *        this path.                                                
   */                                                                 
  new_node = IMFS_create_node(                                        
a0005ba4:	e28d2028 	add	r2, sp, #40	; 0x28                            <== NOT EXECUTED
a0005ba8:	e3a03ca2 	mov	r3, #41472	; 0xa200                           <== NOT EXECUTED
a0005bac:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0005bb0:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a0005bb4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0005bb8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005bbc:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0005bc0:	eb001eb9 	bl	a000d6ac <IMFS_create_node>                    <== NOT EXECUTED
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
a0005bc4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0005bc8:	0a000011 	beq	a0005c14 <IMFS_link+0xb4>                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  /*                                                                  
   * Increment the link count of the node being pointed to.           
   */                                                                 
  info.hard_link.link_node->st_nlink++;                               
a0005bcc:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
  IMFS_update_ctime( info.hard_link.link_node );                      
a0005bd0:	e28d003c 	add	r0, sp, #60	; 0x3c                            <== NOT EXECUTED
a0005bd4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  /*                                                                  
   * Increment the link count of the node being pointed to.           
   */                                                                 
  info.hard_link.link_node->st_nlink++;                               
a0005bd8:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
a0005bdc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0005be0:	e1c323b4 	strh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
  IMFS_update_ctime( info.hard_link.link_node );                      
a0005be4:	eb000217 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a0005be8:	e59d203c 	ldr	r2, [sp, #60]	; 0x3c                          <== NOT EXECUTED
a0005bec:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
a0005bf0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Increment the link count of the node being pointed to.           
   */                                                                 
  info.hard_link.link_node->st_nlink++;                               
  IMFS_update_ctime( info.hard_link.link_node );                      
a0005bf4:	e5832048 	str	r2, [r3, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0005bf8:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0005bfc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   *  Verify this node can be linked to.                              
   */                                                                 
  info.hard_link.link_node = to_loc->node_access;                     
  if ( info.hard_link.link_node->st_nlink >= LINK_MAX )               
    rtems_set_errno_and_return_minus_one( EMLINK );                   
a0005c00:	eb002d36 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005c04:	e3a0301f 	mov	r3, #31                                       <== NOT EXECUTED
a0005c08:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005c0c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005c10:	eafffff8 	b	a0005bf8 <IMFS_link+0x98>                       <== NOT EXECUTED
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if ( !new_node )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
a0005c14:	eb002d31 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005c18:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0005c1c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005c20:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005c24:	eafffff3 	b	a0005bf8 <IMFS_link+0x98>                       <== NOT EXECUTED
                                                                      

a000feb4 <IMFS_memfile_addblock>: */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) {
a000feb4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );                 
                                                                      
  /*                                                                  
   * Obtain the pointer for the specified block number                
   */                                                                 
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
a000feb8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000febc:	ebfffee9 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
  if ( *block_entry_ptr )                                             
a000fec0:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
  IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );                 
                                                                      
  /*                                                                  
   * Obtain the pointer for the specified block number                
   */                                                                 
  block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
a000fec4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  if ( *block_entry_ptr )                                             
a000fec8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000fecc:	0a000001 	beq	a000fed8 <IMFS_memfile_addblock+0x24>         <== NOT EXECUTED
    return 0;                                                         
a000fed0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000fed4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  There is no memory for this block number so allocate it.        
   */                                                                 
  memory = memfile_alloc_block();                                     
a000fed8:	ebfffed5 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
  if ( !memory )                                                      
a000fedc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fee0:	0a000002 	beq	a000fef0 <IMFS_memfile_addblock+0x3c>         <== NOT EXECUTED
    return 1;                                                         
                                                                      
  *block_entry_ptr = memory;                                          
a000fee4:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
  return 0;                                                           
a000fee8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000feec:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   *  There is no memory for this block number so allocate it.        
   */                                                                 
  memory = memfile_alloc_block();                                     
  if ( !memory )                                                      
    return 1;                                                         
a000fef0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
                                                                      
  *block_entry_ptr = memory;                                          
  return 0;                                                           
}                                                                     
a000fef4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a00100e0 <IMFS_memfile_extend>: IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
a00100e0:	e59f3128 	ldr	r3, [pc, #296]	; a0010210 <IMFS_memfile_extend+0x130><== NOT EXECUTED
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
a00100e4:	e92d4df0 	push	{r4, r5, r6, r7, r8, sl, fp, lr}             <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a00100e8:	e593b000 	ldr	fp, [r3]                                      <== NOT EXECUTED
a00100ec:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00100f0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a00100f4:	e1a0312b 	lsr	r3, fp, #2                                    <== NOT EXECUTED
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
a00100f8:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a00100fc:	e0223393 	mla	r2, r3, r3, r3                                <== NOT EXECUTED
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
a0010100:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a0010104:	e0233392 	mla	r3, r2, r3, r3                                <== NOT EXECUTED
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
a0010108:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a001010c:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
   IMFS_jnode_t  *the_jnode,                                          
   off_t          new_length                                          
)                                                                     
{                                                                     
a0010110:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a0010114:	e003039b 	mul	r3, fp, r3                                    <== NOT EXECUTED
a0010118:	da000034 	ble	a00101f0 <IMFS_memfile_extend+0x110>          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /*                                                                  
   *  Verify new file size is actually larger than current size       
   */                                                                 
  if ( new_length <= the_jnode->info.file.size )                      
a001011c:	e5947054 	ldr	r7, [r4, #84]	; 0x54                          <== NOT EXECUTED
a0010120:	e594a050 	ldr	sl, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0010124:	e1560007 	cmp	r6, r7                                        <== NOT EXECUTED
a0010128:	da000027 	ble	a00101cc <IMFS_memfile_extend+0xec>           <== NOT EXECUTED
    return 0;                                                         
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
a001012c:	e1a0cfcb 	asr	ip, fp, #31                                   <== NOT EXECUTED
a0010130:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a0010134:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a0010138:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a001013c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010140:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0010144:	eb001222 	bl	a00149d4 <__divdi3>                            <== NOT EXECUTED
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
a0010148:	e59dc000 	ldr	ip, [sp]                                      <== NOT EXECUTED
    return 0;                                                         
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
a001014c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
a0010150:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010154:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0010158:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a001015c:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a0010160:	eb00121b 	bl	a00149d4 <__divdi3>                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
a0010164:	e1550000 	cmp	r5, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
a0010168:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
a001016c:	3a00001b 	bcc	a00101e0 <IMFS_memfile_extend+0x100>          <== NOT EXECUTED
a0010170:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0010174:	ea000002 	b	a0010184 <IMFS_memfile_extend+0xa4>             <== NOT EXECUTED
a0010178:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
a001017c:	e1550007 	cmp	r5, r7                                        <== NOT EXECUTED
a0010180:	3a000016 	bcc	a00101e0 <IMFS_memfile_extend+0x100>          <== NOT EXECUTED
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
a0010184:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010188:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001018c:	ebffff48 	bl	a000feb4 <IMFS_memfile_addblock>               <== NOT EXECUTED
a0010190:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010194:	0afffff7 	beq	a0010178 <IMFS_memfile_extend+0x98>           <== NOT EXECUTED
a0010198:	ea000003 	b	a00101ac <IMFS_memfile_extend+0xcc>             <== NOT EXECUTED
       for ( ; block>=old_blocks ; block-- ) {                        
         IMFS_memfile_remove_block( the_jnode, block );               
a001019c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00101a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
       for ( ; block>=old_blocks ; block-- ) {                        
a00101a4:	e2477001 	sub	r7, r7, #1                                    <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
a00101a8:	ebffffc2 	bl	a00100b8 <IMFS_memfile_remove_block>           <== NOT EXECUTED
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
    if ( IMFS_memfile_addblock( the_jnode, block ) ) {                
       for ( ; block>=old_blocks ; block-- ) {                        
a00101ac:	e15a0007 	cmp	sl, r7                                        <== NOT EXECUTED
a00101b0:	9afffff9 	bls	a001019c <IMFS_memfile_extend+0xbc>           <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
a00101b4:	eb0003c9 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00101b8:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
a00101bc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00101c0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
  return 0;                                                           
}                                                                     
a00101c4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00101c8:	e8bd8df0 	pop	{r4, r5, r6, r7, r8, sl, fp, pc}              <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /*                                                                  
   *  Verify new file size is actually larger than current size       
   */                                                                 
  if ( new_length <= the_jnode->info.file.size )                      
a00101cc:	1a000001 	bne	a00101d8 <IMFS_memfile_extend+0xf8>           <== NOT EXECUTED
a00101d0:	e158000a 	cmp	r8, sl                                        <== NOT EXECUTED
a00101d4:	8affffd4 	bhi	a001012c <IMFS_memfile_extend+0x4c>           <== NOT EXECUTED
    return 0;                                                         
a00101d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00101dc:	eafffff8 	b	a00101c4 <IMFS_memfile_extend+0xe4>             <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
a00101e0:	e5848050 	str	r8, [r4, #80]	; 0x50                          <== NOT EXECUTED
a00101e4:	e5846054 	str	r6, [r4, #84]	; 0x54                          <== NOT EXECUTED
  return 0;                                                           
a00101e8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00101ec:	eafffff4 	b	a00101c4 <IMFS_memfile_extend+0xe4>             <== NOT EXECUTED
    IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );               
                                                                      
  /*                                                                  
   *  Verify new file size is supported                               
   */                                                                 
  if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )                      
a00101f0:	1a000001 	bne	a00101fc <IMFS_memfile_extend+0x11c>          <== NOT EXECUTED
a00101f4:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a00101f8:	8affffc7 	bhi	a001011c <IMFS_memfile_extend+0x3c>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a00101fc:	eb0003b7 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0010200:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0010204:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0010208:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a001020c:	eaffffec 	b	a00101c4 <IMFS_memfile_extend+0xe4>             <== NOT EXECUTED
                                                                      

a000fa68 <IMFS_memfile_get_block_pointer>: my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) {
a000fa68:	e59f3200 	ldr	r3, [pc, #512]	; a000fc70 <IMFS_memfile_get_block_pointer+0x208><== NOT EXECUTED
#endif                                                                
   IMFS_jnode_t   *the_jnode,                                         
   unsigned int    block,                                             
   int             malloc_it                                          
)                                                                     
{                                                                     
a000fa6c:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  my_block = block;                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
  if ( my_block <= LAST_INDIRECT ) {                                  
a000fa70:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
#endif                                                                
   IMFS_jnode_t   *the_jnode,                                         
   unsigned int    block,                                             
   int             malloc_it                                          
)                                                                     
{                                                                     
a000fa74:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000fa78:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  my_block = block;                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
  if ( my_block <= LAST_INDIRECT ) {                                  
a000fa7c:	e1a05125 	lsr	r5, r5, #2                                    <== NOT EXECUTED
a000fa80:	e2453001 	sub	r3, r5, #1                                    <== NOT EXECUTED
a000fa84:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
#endif                                                                
   IMFS_jnode_t   *the_jnode,                                         
   unsigned int    block,                                             
   int             malloc_it                                          
)                                                                     
{                                                                     
a000fa88:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  my_block = block;                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
  if ( my_block <= LAST_INDIRECT ) {                                  
a000fa8c:	8a000007 	bhi	a000fab0 <IMFS_memfile_get_block_pointer+0x48><== NOT EXECUTED
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
a000fa90:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is the block number in the simple indirect portion?             
   */                                                                 
  if ( my_block <= LAST_INDIRECT ) {                                  
    p = info->indirect;                                               
a000fa94:	e5900058 	ldr	r0, [r0, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    if ( malloc_it ) {                                                
a000fa98:	0a00001c 	beq	a000fb10 <IMFS_memfile_get_block_pointer+0xa8><== NOT EXECUTED
                                                                      
      if ( !p ) {                                                     
a000fa9c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000faa0:	0a000041 	beq	a000fbac <IMFS_memfile_get_block_pointer+0x144><== NOT EXECUTED
    }                                                                 
                                                                      
    if ( !p )                                                         
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
a000faa4:	e0800101 	add	r0, r0, r1, lsl #2                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
  return 0;                                                           
}                                                                     
a000faa8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000faac:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
a000fab0:	e0275595 	mla	r7, r5, r5, r5                                <== NOT EXECUTED
a000fab4:	e2473001 	sub	r3, r7, #1                                    <== NOT EXECUTED
a000fab8:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
a000fabc:	8a000016 	bhi	a000fb1c <IMFS_memfile_get_block_pointer+0xb4><== NOT EXECUTED
    my_block -= FIRST_DOUBLY_INDIRECT;                                
a000fac0:	e0657001 	rsb	r7, r5, r1                                    <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fac4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fac8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000facc:	eb00138c 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fad0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fad4:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fad8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fadc:	eb001342 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
a000fae0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fae4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
    p = info->doubly_indirect;                                        
a000fae8:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
    if ( malloc_it ) {                                                
a000faec:	0a00003f 	beq	a000fbf0 <IMFS_memfile_get_block_pointer+0x188><== NOT EXECUTED
                                                                      
      if ( !p ) {                                                     
a000faf0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000faf4:	0a000045 	beq	a000fc10 <IMFS_memfile_get_block_pointer+0x1a8><== NOT EXECUTED
        if ( !p )                                                     
           return 0;                                                  
        info->doubly_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
a000faf8:	e7930105 	ldr	r0, [r3, r5, lsl #2]                          <== NOT EXECUTED
a000fafc:	e0835105 	add	r5, r3, r5, lsl #2                            <== NOT EXECUTED
      if ( !p1 ) {                                                    
a000fb00:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fb04:	0a00002f 	beq	a000fbc8 <IMFS_memfile_get_block_pointer+0x160><== NOT EXECUTED
                                                                      
    p = (block_p *)p[ doubly ];                                       
    if ( !p )                                                         
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
a000fb08:	e0800108 	add	r0, r0, r8, lsl #2                            <== NOT EXECUTED
a000fb0c:	eaffffe5 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
        info->indirect = p;                                           
      }                                                               
      return &info->indirect[ my_block ];                             
    }                                                                 
                                                                      
    if ( !p )                                                         
a000fb10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fb14:	1affffe2 	bne	a000faa4 <IMFS_memfile_get_block_pointer+0x3c><== NOT EXECUTED
a000fb18:	eaffffe2 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
a000fb1c:	e0235597 	mla	r3, r7, r5, r5                                <== NOT EXECUTED
a000fb20:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000fb24:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
  return 0;                                                           
a000fb28:	83a00000 	movhi	r0, #0                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
a000fb2c:	8affffdd 	bhi	a000faa8 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
    my_block -= FIRST_TRIPLY_INDIRECT;                                
a000fb30:	e0677001 	rsb	r7, r7, r1                                    <== NOT EXECUTED
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fb34:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fb38:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000fb3c:	eb001370 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fb40:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fb44:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fb48:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fb4c:	eb001326 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
a000fb50:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
a000fb54:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
a000fb58:	eb001323 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
a000fb5c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
a000fb60:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
a000fb64:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000fb68:	eb001365 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
a000fb6c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
a000fb70:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
    p = info->triply_indirect;                                        
a000fb74:	e5940060 	ldr	r0, [r4, #96]	; 0x60                          <== NOT EXECUTED
                                                                      
    if ( malloc_it ) {                                                
a000fb78:	0a000029 	beq	a000fc24 <IMFS_memfile_get_block_pointer+0x1bc><== NOT EXECUTED
      if ( !p ) {                                                     
a000fb7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fb80:	0a000035 	beq	a000fc5c <IMFS_memfile_get_block_pointer+0x1f4><== NOT EXECUTED
        if ( !p )                                                     
           return 0;                                                  
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
a000fb84:	e7903107 	ldr	r3, [r0, r7, lsl #2]                          <== NOT EXECUTED
a000fb88:	e0807107 	add	r7, r0, r7, lsl #2                            <== NOT EXECUTED
      if ( !p1 ) {                                                    
a000fb8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000fb90:	0a00002c 	beq	a000fc48 <IMFS_memfile_get_block_pointer+0x1e0><== NOT EXECUTED
        if ( !p1 )                                                    
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
a000fb94:	e7930105 	ldr	r0, [r3, r5, lsl #2]                          <== NOT EXECUTED
a000fb98:	e0835105 	add	r5, r3, r5, lsl #2                            <== NOT EXECUTED
      if ( !p2 ) {                                                    
a000fb9c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fba0:	0a00000d 	beq	a000fbdc <IMFS_memfile_get_block_pointer+0x174><== NOT EXECUTED
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
    if ( !p2 )                                                        
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
a000fba4:	e080010a 	add	r0, r0, sl, lsl #2                            <== NOT EXECUTED
a000fba8:	eaffffbe 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
a000fbac:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a000fbb0:	ebffff9f 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p )                                                     
a000fbb4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fbb8:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
           return 0;                                                  
        info->indirect = p;                                           
a000fbbc:	15840058 	strne	r0, [r4, #88]	; 0x58                        <== NOT EXECUTED
                                                                      
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
        if ( !p )                                                     
a000fbc0:	1affffb7 	bne	a000faa4 <IMFS_memfile_get_block_pointer+0x3c><== NOT EXECUTED
a000fbc4:	eaffffb7 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
        info->doubly_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
a000fbc8:	ebffff99 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p1 )                                                    
a000fbcc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
a000fbd0:	15850000 	strne	r0, [r5]                                    <== NOT EXECUTED
                                                                      
    p = (block_p *)p[ doubly ];                                       
    if ( !p )                                                         
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
a000fbd4:	10800108 	addne	r0, r0, r8, lsl #2                          <== NOT EXECUTED
a000fbd8:	eaffffb2 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
      if ( !p2 ) {                                                    
        p2 = memfile_alloc_block();                                   
a000fbdc:	ebffff94 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p2 )                                                    
a000fbe0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
a000fbe4:	15850000 	strne	r0, [r5]                                    <== NOT EXECUTED
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
    if ( !p2 )                                                        
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
a000fbe8:	1080010a 	addne	r0, r0, sl, lsl #2                          <== NOT EXECUTED
a000fbec:	eaffffad 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
a000fbf0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000fbf4:	1a000001 	bne	a000fc00 <IMFS_memfile_get_block_pointer+0x198><== NOT EXECUTED
                                                                      
      p1 = (block_p *) p[ triply ];                                   
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
        if ( !p1 )                                                    
           return 0;                                                  
a000fbf8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000fbfc:	eaffffa9 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
    }                                                                 
                                                                      
    if ( !p )                                                         
      return 0;                                                       
                                                                      
    p = (block_p *)p[ doubly ];                                       
a000fc00:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
    if ( !p )                                                         
a000fc04:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
a000fc08:	10800108 	addne	r0, r0, r8, lsl #2                          <== NOT EXECUTED
a000fc0c:	eaffffa5 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
a000fc10:	ebffff87 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p )                                                     
a000fc14:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a000fc18:	0afffff6 	beq	a000fbf8 <IMFS_memfile_get_block_pointer+0x190><== NOT EXECUTED
           return 0;                                                  
        info->doubly_indirect = p;                                    
a000fc1c:	e584305c 	str	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a000fc20:	eaffffb4 	b	a000faf8 <IMFS_memfile_get_block_pointer+0x90>  <== NOT EXECUTED
        p1[ doubly ] = (block_p) p2;                                  
      }                                                               
      return (block_p *)&p2[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
a000fc24:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fc28:	0affff9e 	beq	a000faa8 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
      return 0;                                                       
                                                                      
    p1 = (block_p *) p[ triply ];                                     
a000fc2c:	e7900107 	ldr	r0, [r0, r7, lsl #2]                          <== NOT EXECUTED
    if ( !p1 )                                                        
a000fc30:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fc34:	0affff9b 	beq	a000faa8 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
a000fc38:	e7900105 	ldr	r0, [r0, r5, lsl #2]                          <== NOT EXECUTED
    if ( !p2 )                                                        
a000fc3c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
a000fc40:	1080010a 	addne	r0, r0, sl, lsl #2                          <== NOT EXECUTED
a000fc44:	eaffff97 	b	a000faa8 <IMFS_memfile_get_block_pointer+0x40>  <== NOT EXECUTED
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
a000fc48:	ebffff79 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p1 )                                                    
a000fc4c:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a000fc50:	0affffe8 	beq	a000fbf8 <IMFS_memfile_get_block_pointer+0x190><== NOT EXECUTED
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
a000fc54:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
a000fc58:	eaffffcd 	b	a000fb94 <IMFS_memfile_get_block_pointer+0x12c> <== NOT EXECUTED
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
a000fc5c:	ebffff74 	bl	a000fa34 <memfile_alloc_block>                 <== NOT EXECUTED
        if ( !p )                                                     
a000fc60:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fc64:	0affff8f 	beq	a000faa8 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
           return 0;                                                  
        info->triply_indirect = p;                                    
a000fc68:	e5840060 	str	r0, [r4, #96]	; 0x60                          <== NOT EXECUTED
a000fc6c:	eaffffc4 	b	a000fb84 <IMFS_memfile_get_block_pointer+0x11c> <== NOT EXECUTED
                                                                      

a0008910 <IMFS_memfile_maximum_size>: * using the IMFS memory file type. * */ int IMFS_memfile_maximum_size( void ) { return IMFS_MEMFILE_MAXIMUM_SIZE;
a0008910:	e59f3018 	ldr	r3, [pc, #24]	; a0008930 <IMFS_memfile_maximum_size+0x20><== NOT EXECUTED
a0008914:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a0008918:	e1a03122 	lsr	r3, r2, #2                                    <== NOT EXECUTED
a000891c:	e0203393 	mla	r0, r3, r3, r3                                <== NOT EXECUTED
a0008920:	e0233390 	mla	r3, r0, r3, r3                                <== NOT EXECUTED
a0008924:	e2430001 	sub	r0, r3, #1                                    <== NOT EXECUTED
}                                                                     
a0008928:	e0000092 	mul	r0, r2, r0                                    <== NOT EXECUTED
a000892c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000fc74 <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
a000fc74:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a000fc78:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
a000fc7c:	e590004c 	ldr	r0, [r0, #76]	; 0x4c                          <== NOT EXECUTED
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
a000fc80:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
a000fc84:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
a000fc88:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
a000fc8c:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
a000fc90:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
a000fc94:	e59d5038 	ldr	r5, [sp, #56]	; 0x38                          <== NOT EXECUTED
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
a000fc98:	0a00005c 	beq	a000fe10 <IMFS_memfile_read+0x19c>            <== NOT EXECUTED
  /*                                                                  
   *  If the last byte we are supposed to read is past the end of this
   *  in memory file, then shorten the length to read.                
   */                                                                 
  last_byte = start + length;                                         
  if ( last_byte > the_jnode->info.file.size )                        
a000fc9c:	e5992054 	ldr	r2, [r9, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the last byte we are supposed to read is past the end of this
   *  in memory file, then shorten the length to read.                
   */                                                                 
  last_byte = start + length;                                         
a000fca0:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  if ( last_byte > the_jnode->info.file.size )                        
a000fca4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000fca8:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000fcac:	e5992050 	ldr	r2, [r9, #80]	; 0x50                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the last byte we are supposed to read is past the end of this
   *  in memory file, then shorten the length to read.                
   */                                                                 
  last_byte = start + length;                                         
a000fcb0:	e0851007 	add	r1, r5, r7                                    <== NOT EXECUTED
  if ( last_byte > the_jnode->info.file.size )                        
a000fcb4:	da00003d 	ble	a000fdb0 <IMFS_memfile_read+0x13c>            <== NOT EXECUTED
    my_length = the_jnode->info.file.size - start;                    
a000fcb8:	e0635002 	rsb	r5, r3, r2                                    <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
a000fcbc:	e59f61b8 	ldr	r6, [pc, #440]	; a000fe7c <IMFS_memfile_read+0x208><== NOT EXECUTED
a000fcc0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fcc4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000fcc8:	e5964000 	ldr	r4, [r6]                                      <== NOT EXECUTED
a000fccc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000fcd0:	e1a03fc2 	asr	r3, r2, #31                                   <== NOT EXECUTED
a000fcd4:	e98d000c 	stmib	sp, {r2, r3}                                <== NOT EXECUTED
a000fcd8:	eb00146a 	bl	a0014e88 <__moddi3>                            <== NOT EXECUTED
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a000fcdc:	e99d000c 	ldmib	sp, {r2, r3}                                <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
a000fce0:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a000fce4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000fce8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000fcec:	eb001338 	bl	a00149d4 <__divdi3>                            <== NOT EXECUTED
  if ( start_offset )  {                                              
a000fcf0:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a000fcf4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  unsigned int         last_byte;                                     
  unsigned int         copied;                                        
  unsigned int         start_offset;                                  
  unsigned char       *dest;                                          
                                                                      
  dest = destination;                                                 
a000fcf8:	01a0800b 	moveq	r8, fp                                      <== NOT EXECUTED
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
a000fcfc:	0a000014 	beq	a000fd54 <IMFS_memfile_read+0xe0>             <== NOT EXECUTED
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a000fd00:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a000fd04:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000fd08:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000fd0c:	ebffff55 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a000fd10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fd14:	0a000023 	beq	a000fda8 <IMFS_memfile_read+0x134>            <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
a000fd18:	e5901000 	ldr	r1, [r0]                                      <== NOT EXECUTED
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
a000fd1c:	e06a3004 	rsb	r3, sl, r4                                    <== NOT EXECUTED
a000fd20:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
a000fd24:	31a03005 	movcc	r3, r5                                      <== NOT EXECUTED
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
a000fd28:	e081100a 	add	r1, r1, sl                                    <== NOT EXECUTED
a000fd2c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000fd30:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a000fd34:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000fd38:	eb000716 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
    dest += to_copy;                                                  
a000fd3c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    block++;                                                          
    my_length -= to_copy;                                             
a000fd40:	e5964000 	ldr	r4, [r6]                                      <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
    dest += to_copy;                                                  
    block++;                                                          
a000fd44:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
    dest += to_copy;                                                  
a000fd48:	e08b8003 	add	r8, fp, r3                                    <== NOT EXECUTED
    block++;                                                          
    my_length -= to_copy;                                             
a000fd4c:	e0635005 	rsb	r5, r3, r5                                    <== NOT EXECUTED
    copied += to_copy;                                                
a000fd50:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a000fd54:	e1550004 	cmp	r5, r4                                        <== NOT EXECUTED
a000fd58:	2a000008 	bcs	a000fd80 <IMFS_memfile_read+0x10c>            <== NOT EXECUTED
a000fd5c:	ea000017 	b	a000fdc0 <IMFS_memfile_read+0x14c>              <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
a000fd60:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a000fd64:	eb00070b 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a000fd68:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
    dest += to_copy;                                                  
a000fd6c:	e0888004 	add	r8, r8, r4                                    <== NOT EXECUTED
    block++;                                                          
a000fd70:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a000fd74:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
    dest += to_copy;                                                  
    block++;                                                          
    my_length -= to_copy;                                             
    copied += to_copy;                                                
a000fd78:	e08aa004 	add	sl, sl, r4                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a000fd7c:	8a00000f 	bhi	a000fdc0 <IMFS_memfile_read+0x14c>            <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a000fd80:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000fd84:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000fd88:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a000fd8c:	ebffff35 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a000fd90:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
a000fd94:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    dest += to_copy;                                                  
    block++;                                                          
    my_length -= to_copy;                                             
a000fd98:	e0645005 	rsb	r5, r4, r5                                    <== NOT EXECUTED
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
a000fd9c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
a000fda0:	1affffee 	bne	a000fd60 <IMFS_memfile_read+0xec>             <== NOT EXECUTED
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  if ( my_length ) {                                                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
      return copied;                                                  
a000fda4:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
                                                                      
  return copied;                                                      
}                                                                     
a000fda8:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a000fdac:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  /*                                                                  
   *  If the last byte we are supposed to read is past the end of this
   *  in memory file, then shorten the length to read.                
   */                                                                 
  last_byte = start + length;                                         
  if ( last_byte > the_jnode->info.file.size )                        
a000fdb0:	1affffc1 	bne	a000fcbc <IMFS_memfile_read+0x48>             <== NOT EXECUTED
a000fdb4:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000fdb8:	9affffbf 	bls	a000fcbc <IMFS_memfile_read+0x48>             <== NOT EXECUTED
a000fdbc:	eaffffbd 	b	a000fcb8 <IMFS_memfile_read+0x44>               <== NOT EXECUTED
  /*                                                                  
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  if ( my_length ) {                                                  
a000fdc0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000fdc4:	0a00000a 	beq	a000fdf4 <IMFS_memfile_read+0x180>            <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a000fdc8:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a000fdcc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000fdd0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000fdd4:	ebffff23 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a000fdd8:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a000fddc:	0afffff0 	beq	a000fda4 <IMFS_memfile_read+0x130>            <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
a000fde0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000fde4:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a000fde8:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000fdec:	eb0006e9 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
    copied += my_length;                                              
a000fdf0:	e08aa005 	add	sl, sl, r5                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
a000fdf4:	e28d000c 	add	r0, sp, #12                                   <== NOT EXECUTED
a000fdf8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000fdfc:	ebffd991 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a000fe00:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  return copied;                                                      
a000fe04:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
a000fe08:	e5893040 	str	r3, [r9, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  return copied;                                                      
a000fe0c:	eaffffe5 	b	a000fda8 <IMFS_memfile_read+0x134>              <== NOT EXECUTED
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
a000fe10:	e2894050 	add	r4, r9, #80	; 0x50                            <== NOT EXECUTED
a000fe14:	e8940018 	ldm	r4, {r3, r4}                                  <== NOT EXECUTED
a000fe18:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000fe1c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000fe20:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000fe24:	e0500007 	subs	r0, r0, r7                                   <== NOT EXECUTED
a000fe28:	e0c11008 	sbc	r1, r1, r8                                    <== NOT EXECUTED
a000fe2c:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
  my_length = length;                                                 
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
a000fe30:	e5992058 	ldr	r2, [r9, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
a000fe34:	da00000b 	ble	a000fe68 <IMFS_memfile_read+0x1f4>            <== NOT EXECUTED
      my_length = the_jnode->info.linearfile.size - start;            
a000fe38:	e067a003 	rsb	sl, r7, r3                                    <== NOT EXECUTED
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
a000fe3c:	e0821007 	add	r1, r2, r7                                    <== NOT EXECUTED
a000fe40:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a000fe44:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
a000fe48:	eb0006d2 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
a000fe4c:	e28d000c 	add	r0, sp, #12                                   <== NOT EXECUTED
a000fe50:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000fe54:	ebffd97b 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a000fe58:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  return copied;                                                      
a000fe5c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
a000fe60:	e5893040 	str	r3, [r9, #64]	; 0x40                          <== NOT EXECUTED
a000fe64:	eaffffcf 	b	a000fda8 <IMFS_memfile_read+0x134>              <== NOT EXECUTED
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
a000fe68:	1a000001 	bne	a000fe74 <IMFS_memfile_read+0x200>            <== NOT EXECUTED
a000fe6c:	e1550000 	cmp	r5, r0                                        <== NOT EXECUTED
a000fe70:	8afffff0 	bhi	a000fe38 <IMFS_memfile_read+0x1c4>            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Linear files (as created from a tar file are easier to handle   
   *  than block files).                                              
   */                                                                 
  my_length = length;                                                 
a000fe74:	e1a0a005 	mov	sl, r5                                        <== NOT EXECUTED
a000fe78:	eaffffef 	b	a000fe3c <IMFS_memfile_read+0x1c8>              <== NOT EXECUTED
                                                                      

a000ff6c <IMFS_memfile_remove>: * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
a000ff6c:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Eventually this could be set smarter at each call to            
   *  memfile_free_blocks_in_table to greatly speed this up.          
   */                                                                 
  to_free = IMFS_MEMFILE_BLOCK_SLOTS;                                 
a000ff70:	e59f613c 	ldr	r6, [pc, #316]	; a00100b4 <IMFS_memfile_remove+0x148><== NOT EXECUTED
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
a000ff74:	e5903058 	ldr	r3, [r0, #88]	; 0x58                          <== NOT EXECUTED
 *         is better to stick to simple, easy to understand algorithms.
 */                                                                   
int IMFS_memfile_remove(                                              
 IMFS_jnode_t  *the_jnode                                             
)                                                                     
{                                                                     
a000ff78:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Eventually this could be set smarter at each call to            
   *  memfile_free_blocks_in_table to greatly speed this up.          
   */                                                                 
  to_free = IMFS_MEMFILE_BLOCK_SLOTS;                                 
a000ff7c:	e5967000 	ldr	r7, [r6]                                      <== NOT EXECUTED
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
a000ff80:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Eventually this could be set smarter at each call to            
   *  memfile_free_blocks_in_table to greatly speed this up.          
   */                                                                 
  to_free = IMFS_MEMFILE_BLOCK_SLOTS;                                 
a000ff84:	e1a07127 	lsr	r7, r7, #2                                    <== NOT EXECUTED
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
a000ff88:	0a000002 	beq	a000ff98 <IMFS_memfile_remove+0x2c>           <== NOT EXECUTED
    memfile_free_blocks_in_table( &info->indirect, to_free );         
a000ff8c:	e2800058 	add	r0, r0, #88	; 0x58                            <== NOT EXECUTED
a000ff90:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000ff94:	ebffffdf 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
a000ff98:	e59a305c 	ldr	r3, [sl, #92]	; 0x5c                          <== NOT EXECUTED
a000ff9c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ffa0:	0a000015 	beq	a000fffc <IMFS_memfile_remove+0x90>           <== NOT EXECUTED
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
a000ffa4:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
a000ffa8:	e1b02122 	lsrs	r2, r2, #2                                   <== NOT EXECUTED
a000ffac:	0a00000f 	beq	a000fff0 <IMFS_memfile_remove+0x84>           <== NOT EXECUTED
a000ffb0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000ffb4:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a000ffb8:	ea000000 	b	a000ffc0 <IMFS_memfile_remove+0x54>             <== NOT EXECUTED
a000ffbc:	e59a305c 	ldr	r3, [sl, #92]	; 0x5c                          <== NOT EXECUTED
      if ( info->doubly_indirect[i] ) {                               
a000ffc0:	e7930102 	ldr	r0, [r3, r2, lsl #2]                          <== NOT EXECUTED
a000ffc4:	e1a02102 	lsl	r2, r2, #2                                    <== NOT EXECUTED
  if ( info->indirect ) {                                             
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
a000ffc8:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
      if ( info->doubly_indirect[i] ) {                               
a000ffcc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        memfile_free_blocks_in_table(                                 
a000ffd0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000ffd4:	e0830002 	add	r0, r3, r2                                    <== NOT EXECUTED
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      if ( info->doubly_indirect[i] ) {                               
a000ffd8:	0a000000 	beq	a000ffe0 <IMFS_memfile_remove+0x74>           <== NOT EXECUTED
        memfile_free_blocks_in_table(                                 
a000ffdc:	ebffffcd 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
  if ( info->indirect ) {                                             
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
a000ffe0:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a000ffe4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000ffe8:	e1540123 	cmp	r4, r3, lsr #2                                <== NOT EXECUTED
a000ffec:	3afffff2 	bcc	a000ffbc <IMFS_memfile_remove+0x50>           <== NOT EXECUTED
      if ( info->doubly_indirect[i] ) {                               
        memfile_free_blocks_in_table(                                 
         (block_p **)&info->doubly_indirect[i], to_free );            
      }                                                               
    }                                                                 
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
a000fff0:	e28a005c 	add	r0, sl, #92	; 0x5c                            <== NOT EXECUTED
a000fff4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000fff8:	ebffffc6 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
a000fffc:	e59a0060 	ldr	r0, [sl, #96]	; 0x60                          <== NOT EXECUTED
a0010000:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010004:	0a000028 	beq	a00100ac <IMFS_memfile_remove+0x140>          <== NOT EXECUTED
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
a0010008:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a001000c:	e1b03123 	lsrs	r3, r3, #2                                   <== NOT EXECUTED
a0010010:	0a000022 	beq	a00100a0 <IMFS_memfile_remove+0x134>          <== NOT EXECUTED
      p = (block_p *) info->triply_indirect[i];                       
a0010014:	e5905000 	ldr	r5, [r0]                                      <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
a0010018:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
a001001c:	13a09000 	movne	r9, #0                                      <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
a0010020:	11a08009 	movne	r8, r9                                      <== NOT EXECUTED
a0010024:	0a00001d 	beq	a00100a0 <IMFS_memfile_remove+0x134>          <== NOT EXECUTED
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
a0010028:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a001002c:	0a00000e 	beq	a001006c <IMFS_memfile_remove+0x100>          <== NOT EXECUTED
a0010030:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010034:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
        if ( p[j] ) {                                                 
a0010038:	e7953100 	ldr	r3, [r5, r0, lsl #2]                          <== NOT EXECUTED
a001003c:	e1a00100 	lsl	r0, r0, #2                                    <== NOT EXECUTED
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
      if ( !p )  /* ensure we have a valid pointer */                 
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
a0010040:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
        if ( p[j] ) {                                                 
a0010044:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
a0010048:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a001004c:	e0850000 	add	r0, r5, r0                                    <== NOT EXECUTED
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
      if ( !p )  /* ensure we have a valid pointer */                 
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
        if ( p[j] ) {                                                 
a0010050:	0a000000 	beq	a0010058 <IMFS_memfile_remove+0xec>           <== NOT EXECUTED
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
a0010054:	ebffffaf 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
      if ( !p )  /* ensure we have a valid pointer */                 
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
a0010058:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a001005c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010060:	e1540123 	cmp	r4, r3, lsr #2                                <== NOT EXECUTED
a0010064:	3afffff3 	bcc	a0010038 <IMFS_memfile_remove+0xcc>           <== NOT EXECUTED
a0010068:	e59a0060 	ldr	r0, [sl, #96]	; 0x60                          <== NOT EXECUTED
        if ( p[j] ) {                                                 
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
a001006c:	e0800009 	add	r0, r0, r9                                    <== NOT EXECUTED
a0010070:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010074:	ebffffa7 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
a0010078:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a001007c:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
a0010080:	e1a03123 	lsr	r3, r3, #2                                    <== NOT EXECUTED
a0010084:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
a0010088:	9a000004 	bls	a00100a0 <IMFS_memfile_remove+0x134>          <== NOT EXECUTED
      p = (block_p *) info->triply_indirect[i];                       
a001008c:	e59a0060 	ldr	r0, [sl, #96]	; 0x60                          <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
a0010090:	e1a09108 	lsl	r9, r8, #2                                    <== NOT EXECUTED
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
a0010094:	e7905108 	ldr	r5, [r0, r8, lsl #2]                          <== NOT EXECUTED
      if ( !p )  /* ensure we have a valid pointer */                 
a0010098:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a001009c:	1affffe1 	bne	a0010028 <IMFS_memfile_remove+0xbc>           <== NOT EXECUTED
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
        (block_p **)&info->triply_indirect[i], to_free );             
    }                                                                 
    memfile_free_blocks_in_table(                                     
a00100a0:	e28a0060 	add	r0, sl, #96	; 0x60                            <== NOT EXECUTED
a00100a4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00100a8:	ebffff9a 	bl	a000ff18 <memfile_free_blocks_in_table>        <== NOT EXECUTED
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a00100ac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00100b0:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

a00100b8 <IMFS_memfile_remove_block>: */ MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
a00100b8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  block_p *block_ptr;                                                 
  block_p  ptr;                                                       
                                                                      
  block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );  
a00100bc:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00100c0:	ebfffe68 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
  *block_ptr = 0;                                                     
a00100c4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  block_p *block_ptr;                                                 
  block_p  ptr;                                                       
                                                                      
  block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );  
a00100c8:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
a00100cc:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
  *block_ptr = 0;                                                     
a00100d0:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
  memfile_free_block( ptr );                                          
a00100d4:	ebffff87 	bl	a000fef8 <memfile_free_block>                  <== NOT EXECUTED
                                                                      
  return 1;                                                           
}                                                                     
a00100d8:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a00100dc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0010214 <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
a0010214:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0010218:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
a001021c:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
a0010220:	e5900054 	ldr	r0, [r0, #84]	; 0x54                          <== NOT EXECUTED
   IMFS_jnode_t          *the_jnode,                                  
   off_t                  start,                                      
   const unsigned char   *source,                                     
   unsigned int           length                                      
)                                                                     
{                                                                     
a0010224:	e59db034 	ldr	fp, [sp, #52]	; 0x34                          <== NOT EXECUTED
a0010228:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
a001022c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   IMFS_jnode_t          *the_jnode,                                  
   off_t                  start,                                      
   const unsigned char   *source,                                     
   unsigned int           length                                      
)                                                                     
{                                                                     
a0010230:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
a0010234:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  /*                                                                  
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
a0010238:	e08b1001 	add	r1, fp, r1                                    <== NOT EXECUTED
  if ( last_byte > the_jnode->info.file.size ) {                      
a001023c:	ba000054 	blt	a0010394 <IMFS_memfile_write+0x180>           <== NOT EXECUTED
a0010240:	0a000050 	beq	a0010388 <IMFS_memfile_write+0x174>           <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
a0010244:	e59f5170 	ldr	r5, [pc, #368]	; a00103bc <IMFS_memfile_write+0x1a8><== NOT EXECUTED
a0010248:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a001024c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010250:	e5954000 	ldr	r4, [r5]                                      <== NOT EXECUTED
a0010254:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0010258:	e1a03fc2 	asr	r3, r2, #31                                   <== NOT EXECUTED
a001025c:	e88d000c 	stm	sp, {r2, r3}                                  <== NOT EXECUTED
a0010260:	eb001308 	bl	a0014e88 <__moddi3>                            <== NOT EXECUTED
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a0010264:	e89d000c 	ldm	sp, {r2, r3}                                  <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
a0010268:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a001026c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010270:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010274:	eb0011d6 	bl	a00149d4 <__divdi3>                            <== NOT EXECUTED
  if ( start_offset )  {                                              
a0010278:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
a001027c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  if ( start_offset )  {                                              
a0010280:	01a0600b 	moveq	r6, fp                                      <== NOT EXECUTED
a0010284:	1a000016 	bne	a00102e4 <IMFS_memfile_write+0xd0>            <== NOT EXECUTED
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a0010288:	e1560004 	cmp	r6, r4                                        <== NOT EXECUTED
a001028c:	2a000008 	bcs	a00102b4 <IMFS_memfile_write+0xa0>            <== NOT EXECUTED
a0010290:	ea000027 	b	a0010334 <IMFS_memfile_write+0x120>             <== NOT EXECUTED
    if ( !block_ptr )                                                 
      return copied;                                                  
    #if 0                                                             
      fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
    #endif                                                            
    memcpy( &(*block_ptr)[ 0 ], src, to_copy );                       
a0010294:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a0010298:	eb0005be 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a001029c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
      return copied;                                                  
    #if 0                                                             
      fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
    #endif                                                            
    memcpy( &(*block_ptr)[ 0 ], src, to_copy );                       
    src += to_copy;                                                   
a00102a0:	e0888004 	add	r8, r8, r4                                    <== NOT EXECUTED
    block++;                                                          
a00102a4:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a00102a8:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
 *  IMFS_memfile_write                                                
 *                                                                    
 *  This routine writes the specified data buffer into the in memory  
 *  file pointed to by the_jnode.  The file is extended as needed.    
 */                                                                   
MEMFILE_STATIC ssize_t IMFS_memfile_write(                            
a00102ac:	e08aa004 	add	sl, sl, r4                                    <== NOT EXECUTED
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
a00102b0:	8a00001f 	bhi	a0010334 <IMFS_memfile_write+0x120>           <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a00102b4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00102b8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00102bc:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a00102c0:	ebfffde8 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a00102c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      return copied;                                                  
    #if 0                                                             
      fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
    #endif                                                            
    memcpy( &(*block_ptr)[ 0 ], src, to_copy );                       
a00102c8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a00102cc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    src += to_copy;                                                   
    block++;                                                          
    my_length -= to_copy;                                             
a00102d0:	e0646006 	rsb	r6, r4, r6                                    <== NOT EXECUTED
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
a00102d4:	1affffee 	bne	a0010294 <IMFS_memfile_write+0x80>            <== NOT EXECUTED
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
    if ( !block_ptr )                                                 
a00102d8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
a00102dc:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a00102e0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a00102e4:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a00102e8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00102ec:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00102f0:	ebfffddc 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a00102f4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00102f8:	0afffff7 	beq	a00102dc <IMFS_memfile_write+0xc8>            <== NOT EXECUTED
        block,                                                        
        to_copy,                                                      
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
a00102fc:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
a0010300:	e06a4004 	rsb	r4, sl, r4                                    <== NOT EXECUTED
a0010304:	e154000b 	cmp	r4, fp                                        <== NOT EXECUTED
a0010308:	21a0400b 	movcs	r4, fp                                      <== NOT EXECUTED
        block,                                                        
        to_copy,                                                      
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
a001030c:	e080000a 	add	r0, r0, sl                                    <== NOT EXECUTED
a0010310:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0010314:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0010318:	eb00059e 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
    src += to_copy;                                                   
a001031c:	e0888004 	add	r8, r8, r4                                    <== NOT EXECUTED
    block++;                                                          
    my_length -= to_copy;                                             
a0010320:	e064600b 	rsb	r6, r4, fp                                    <== NOT EXECUTED
    copied += to_copy;                                                
a0010324:	e1a0a004 	mov	sl, r4                                        <== NOT EXECUTED
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
    src += to_copy;                                                   
    block++;                                                          
a0010328:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
    my_length -= to_copy;                                             
    copied += to_copy;                                                
a001032c:	e5954000 	ldr	r4, [r5]                                      <== NOT EXECUTED
a0010330:	eaffffd4 	b	a0010288 <IMFS_memfile_write+0x74>              <== NOT EXECUTED
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  to_copy = my_length;                                                
  if ( my_length ) {                                                  
a0010334:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0010338:	0a00000a 	beq	a0010368 <IMFS_memfile_write+0x154>           <== NOT EXECUTED
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
a001033c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0010340:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010344:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0010348:	ebfffdc6 	bl	a000fa68 <IMFS_memfile_get_block_pointer>      <== NOT EXECUTED
    if ( !block_ptr )                                                 
a001034c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010350:	0affffe0 	beq	a00102d8 <IMFS_memfile_write+0xc4>            <== NOT EXECUTED
      return copied;                                                  
    #if 0                                                             
    fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
    #endif                                                            
    memcpy( &(*block_ptr)[ 0 ], src, my_length );                     
a0010354:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a0010358:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a001035c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0010360:	eb00058c 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
    my_length = 0;                                                    
    copied += to_copy;                                                
a0010364:	e08aa006 	add	sl, sl, r6                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
a0010368:	e28d0008 	add	r0, sp, #8                                    <== NOT EXECUTED
a001036c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010370:	ebffd834 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a0010374:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  return copied;                                                      
a0010378:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
    memcpy( &(*block_ptr)[ 0 ], src, my_length );                     
    my_length = 0;                                                    
    copied += to_copy;                                                
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
a001037c:	e5893044 	str	r3, [r9, #68]	; 0x44                          <== NOT EXECUTED
a0010380:	e5893048 	str	r3, [r9, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return copied;                                                      
a0010384:	eaffffd4 	b	a00102dc <IMFS_memfile_write+0xc8>              <== NOT EXECUTED
   *  If the last byte we are supposed to write is past the end of this
   *  in memory file, then extend the length.                         
   */                                                                 
                                                                      
  last_byte = start + my_length;                                      
  if ( last_byte > the_jnode->info.file.size ) {                      
a0010388:	e5993050 	ldr	r3, [r9, #80]	; 0x50                          <== NOT EXECUTED
a001038c:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a0010390:	2affffab 	bcs	a0010244 <IMFS_memfile_write+0x30>            <== NOT EXECUTED
    status = IMFS_memfile_extend( the_jnode, last_byte );             
a0010394:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0010398:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a001039c:	ebffff4f 	bl	a00100e0 <IMFS_memfile_extend>                 <== NOT EXECUTED
    if ( status )                                                     
a00103a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00103a4:	0affffa6 	beq	a0010244 <IMFS_memfile_write+0x30>            <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
a00103a8:	eb00034c 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00103ac:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
a00103b0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00103b4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00103b8:	eaffffc7 	b	a00102dc <IMFS_memfile_write+0xc8>              <== NOT EXECUTED
                                                                      

a0005c28 <IMFS_mknod>: const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) {
a0005c28:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
a0005c2c:	e24dd040 	sub	sp, sp, #64	; 0x40                            
a0005c30:	e1a04001 	mov	r4, r1                                        
a0005c34:	e1a08000 	mov	r8, r0                                        
a0005c38:	e1a07002 	mov	r7, r2                                        
a0005c3c:	e1a06003 	mov	r6, r3                                        
  IMFS_jnode_t      *new_node;                                        
  int                result;                                          
  char               new_name[ IMFS_NAME_MAX + 1 ];                   
  IMFS_types_union   info;                                            
                                                                      
  IMFS_get_token( token, strlen( token ), new_name, &result );        
a0005c40:	eb003110 	bl	a0012088 <strlen>                              
a0005c44:	e28d5004 	add	r5, sp, #4                                    
a0005c48:	e1a01000 	mov	r1, r0                                        
a0005c4c:	e1a02005 	mov	r2, r5                                        
a0005c50:	e1a00008 	mov	r0, r8                                        
a0005c54:	e28d303c 	add	r3, sp, #60	; 0x3c                            
a0005c58:	eb00212f 	bl	a000e11c <IMFS_get_token>                      
                                                                      
  /*                                                                  
   *  Figure out what type of IMFS node this is.                      
   */                                                                 
  if ( S_ISDIR(mode) )                                                
a0005c5c:	e2041a0f 	and	r1, r4, #61440	; 0xf000                       
a0005c60:	e3510901 	cmp	r1, #16384	; 0x4000                           
    type = IMFS_DIRECTORY;                                            
a0005c64:	03a01001 	moveq	r1, #1                                      
  IMFS_get_token( token, strlen( token ), new_name, &result );        
                                                                      
  /*                                                                  
   *  Figure out what type of IMFS node this is.                      
   */                                                                 
  if ( S_ISDIR(mode) )                                                
a0005c68:	0a000008 	beq	a0005c90 <IMFS_mknod+0x68>                    
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
a0005c6c:	e3510902 	cmp	r1, #32768	; 0x8000                           
    type = IMFS_MEMORY_FILE;                                          
a0005c70:	03a01005 	moveq	r1, #5                                      
  /*                                                                  
   *  Figure out what type of IMFS node this is.                      
   */                                                                 
  if ( S_ISDIR(mode) )                                                
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
a0005c74:	0a000005 	beq	a0005c90 <IMFS_mknod+0x68>                    
    type = IMFS_MEMORY_FILE;                                          
  else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {                        
a0005c78:	e3510a06 	cmp	r1, #24576	; 0x6000                           
a0005c7c:	13510a02 	cmpne	r1, #8192	; 0x2000                          
    type = IMFS_DEVICE;                                               
    rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
a0005c80:	058d7028 	streq	r7, [sp, #40]	; 0x28                        
a0005c84:	058d602c 	streq	r6, [sp, #44]	; 0x2c                        
  if ( S_ISDIR(mode) )                                                
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
    type = IMFS_MEMORY_FILE;                                          
  else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {                        
    type = IMFS_DEVICE;                                               
a0005c88:	03a01002 	moveq	r1, #2                                      
   */                                                                 
  if ( S_ISDIR(mode) )                                                
    type = IMFS_DIRECTORY;                                            
  else if ( S_ISREG(mode) )                                           
    type = IMFS_MEMORY_FILE;                                          
  else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {                        
a0005c8c:	1a00000a 	bne	a0005cbc <IMFS_mknod+0x94>                    
   *        was ONLY passed a NULL when we created the root node.  We 
   *        added a new IMFS_create_root_node() so this path no longer
   *        existed.  The result was simpler code which should not have
   *        this path.                                                
   */                                                                 
  new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
a0005c90:	e28d3028 	add	r3, sp, #40	; 0x28                            
a0005c94:	e58d3000 	str	r3, [sp]                                      
a0005c98:	e59d0058 	ldr	r0, [sp, #88]	; 0x58                          
a0005c9c:	e1a02005 	mov	r2, r5                                        
a0005ca0:	e1a03004 	mov	r3, r4                                        
a0005ca4:	eb001e80 	bl	a000d6ac <IMFS_create_node>                    
  if ( !new_node )                                                    
a0005ca8:	e3500000 	cmp	r0, #0                                        
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  return 0;                                                           
a0005cac:	13a00000 	movne	r0, #0                                      
   *        added a new IMFS_create_root_node() so this path no longer
   *        existed.  The result was simpler code which should not have
   *        this path.                                                
   */                                                                 
  new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
  if ( !new_node )                                                    
a0005cb0:	0a000005 	beq	a0005ccc <IMFS_mknod+0xa4>                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  return 0;                                                           
}                                                                     
a0005cb4:	e28dd040 	add	sp, sp, #64	; 0x40                            
a0005cb8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
  mode_t                             mode,       /* IN */             
  dev_t                              dev,        /* IN */             
  rtems_filesystem_location_info_t  *pathloc     /* IN/OUT */         
)                                                                     
{                                                                     
  IMFS_token_types   type = 0;                                        
a0005cbc:	e3510a01 	cmp	r1, #4096	; 0x1000                            <== NOT EXECUTED
a0005cc0:	03a01007 	moveq	r1, #7                                      <== NOT EXECUTED
a0005cc4:	13a01000 	movne	r1, #0                                      <== NOT EXECUTED
a0005cc8:	eafffff0 	b	a0005c90 <IMFS_mknod+0x68>                      <== NOT EXECUTED
   *        existed.  The result was simpler code which should not have
   *        this path.                                                
   */                                                                 
  new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
  if ( !new_node )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
a0005ccc:	eb002d03 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005cd0:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0005cd4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005cd8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005cdc:	eafffff4 	b	a0005cb4 <IMFS_mknod+0x8c>                      <== NOT EXECUTED
                                                                      

a0005ce0 <IMFS_mount>: rtems_filesystem_mount_table_entry_t *mt_entry ) { IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access;
a0005ce0:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int IMFS_mount(                                                       
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
a0005ce4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is the node that we are mounting onto a directory node ?        
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
a0005ce8:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a0005cec:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
a0005cf0:	1a000002 	bne	a0005d00 <IMFS_mount+0x20>                    <== NOT EXECUTED
  /*                                                                  
   *  Set mt_fs pointer to point to the mount table entry for         
   *  the mounted file system.                                        
   */                                                                 
                                                                      
  node->info.directory.mt_fs = mt_entry;                              
a0005cf4:	e583005c 	str	r0, [r3, #92]	; 0x5c                          <== NOT EXECUTED
  return 0;                                                           
a0005cf8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0005cfc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  /*                                                                  
   *  Is the node that we are mounting onto a directory node ?        
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a0005d00:	eb002cf6 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005d04:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a0005d08:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005d0c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005d10:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0005d14 <IMFS_node_type>: ) { IMFS_jnode_t *node; node = pathloc->node_access; return node->type;
a0005d14:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
}                                                                     
a0005d18:	e593004c 	ldr	r0, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a0005d1c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00086e4 <IMFS_print_jnode>: * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) {
a00086e4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
a00086e8:	e59f50f8 	ldr	r5, [pc, #248]	; a00087e8 <IMFS_print_jnode+0x104><== NOT EXECUTED
 *  This routine prints the contents of the specified jnode.          
 */                                                                   
void IMFS_print_jnode(                                                
  IMFS_jnode_t *the_jnode                                             
)                                                                     
{                                                                     
a00086ec:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
a00086f0:	e280000c 	add	r0, r0, #12                                   <== NOT EXECUTED
a00086f4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00086f8:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
a00086fc:	eb0034d9 	bl	a0015a68 <fputs>                               <== NOT EXECUTED
  switch( the_jnode->type ) {                                         
a0008700:	e594204c 	ldr	r2, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a0008704:	e2423001 	sub	r3, r2, #1                                    <== NOT EXECUTED
a0008708:	e3530006 	cmp	r3, #6                                        <== NOT EXECUTED
a000870c:	979ff103 	ldrls	pc, [pc, r3, lsl #2]                        <== NOT EXECUTED
a0008710:	ea000023 	b	a00087a4 <IMFS_print_jnode+0xc0>                <== NOT EXECUTED
a0008714:	a00087b8 	.word	0xa00087b8                                  <== NOT EXECUTED
a0008718:	a00087cc 	.word	0xa00087cc                                  <== NOT EXECUTED
a000871c:	a0008730 	.word	0xa0008730                                  <== NOT EXECUTED
a0008720:	a0008730 	.word	0xa0008730                                  <== NOT EXECUTED
a0008724:	a0008768 	.word	0xa0008768                                  <== NOT EXECUTED
a0008728:	a0008788 	.word	0xa0008788                                  <== NOT EXECUTED
a000872c:	a000874c 	.word	0xa000874c                                  <== NOT EXECUTED
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
a0008730:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0008734:	e59f00b0 	ldr	r0, [pc, #176]	; a00087ec <IMFS_print_jnode+0x108><== NOT EXECUTED
a0008738:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000873c:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0008740:	e3a02013 	mov	r2, #19                                       <== NOT EXECUTED
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      return;                                                         
  }                                                                   
  puts("");                                                           
}                                                                     
a0008744:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
a0008748:	ea0037f6 	b	a0016728 <fwrite>                               <== NOT EXECUTED
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
a000874c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0008750:	e59f0098 	ldr	r0, [pc, #152]	; a00087f0 <IMFS_print_jnode+0x10c><== NOT EXECUTED
a0008754:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0008758:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a000875c:	e3a02012 	mov	r2, #18                                       <== NOT EXECUTED
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      return;                                                         
  }                                                                   
  puts("");                                                           
}                                                                     
a0008760:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
a0008764:	ea0037ef 	b	a0016728 <fwrite>                               <== NOT EXECUTED
        the_jnode->info.file.indirect,                                
        the_jnode->info.file.doubly_indirect,                         
        the_jnode->info.file.triply_indirect                          
      );                                                              
#else                                                                 
      fprintf(stdout, " (file %" PRId32 ")",                          
a0008768:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000876c:	e59f1080 	ldr	r1, [pc, #128]	; a00087f4 <IMFS_print_jnode+0x110><== NOT EXECUTED
a0008770:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0008774:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a0008778:	eb003465 	bl	a0015914 <fprintf>                             <== NOT EXECUTED
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      return;                                                         
  }                                                                   
  puts("");                                                           
a000877c:	e59f0074 	ldr	r0, [pc, #116]	; a00087f8 <IMFS_print_jnode+0x114><== NOT EXECUTED
}                                                                     
a0008780:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
      return;                                                         
  }                                                                   
  puts("");                                                           
a0008784:	ea003bc9 	b	a00176b0 <puts>                                 <== NOT EXECUTED
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      fprintf(stdout, " (file %" PRId32 " %p)",                       
a0008788:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000878c:	e59f1068 	ldr	r1, [pc, #104]	; a00087fc <IMFS_print_jnode+0x118><== NOT EXECUTED
a0008790:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0008794:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a0008798:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
a000879c:	eb00345c 	bl	a0015914 <fprintf>                             <== NOT EXECUTED
        (uint32_t)the_jnode->info.linearfile.size,                    
        the_jnode->info.linearfile.direct                             
      );                                                              
      break;                                                          
a00087a0:	eafffff5 	b	a000877c <IMFS_print_jnode+0x98>                <== NOT EXECUTED
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
a00087a4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00087a8:	e59f1050 	ldr	r1, [pc, #80]	; a0008800 <IMFS_print_jnode+0x11c><== NOT EXECUTED
a00087ac:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
      return;                                                         
  }                                                                   
  puts("");                                                           
}                                                                     
a00087b0:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", the_jnode->type );            
a00087b4:	ea003456 	b	a0015914 <fprintf>                              <== NOT EXECUTED
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  switch( the_jnode->type ) {                                         
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
a00087b8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00087bc:	e3a0002f 	mov	r0, #47	; 0x2f                                <== NOT EXECUTED
a00087c0:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
a00087c4:	eb003472 	bl	a0015994 <fputc>                               <== NOT EXECUTED
      break;                                                          
a00087c8:	eaffffeb 	b	a000877c <IMFS_print_jnode+0x98>                <== NOT EXECUTED
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
a00087cc:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00087d0:	e59f102c 	ldr	r1, [pc, #44]	; a0008804 <IMFS_print_jnode+0x120><== NOT EXECUTED
a00087d4:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          <== NOT EXECUTED
a00087d8:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a00087dc:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          <== NOT EXECUTED
a00087e0:	eb00344b 	bl	a0015914 <fprintf>                             <== NOT EXECUTED
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
a00087e4:	eaffffe4 	b	a000877c <IMFS_print_jnode+0x98>                <== NOT EXECUTED
                                                                      

a0005d20 <IMFS_readlink>: node = loc->node_access; IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
a0005d20:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
ssize_t IMFS_readlink(                                                
  rtems_filesystem_location_info_t  *loc,                             
  char                              *buf,         /* OUT */           
  size_t                             bufsize                          
)                                                                     
{                                                                     
a0005d24:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
  IMFS_jnode_t      *node;                                            
  ssize_t            i;                                               
                                                                      
  node = loc->node_access;                                            
a0005d28:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
                                                                      
  IMFS_assert( node->type == IMFS_SYM_LINK );                         
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
a0005d2c:	01a00002 	moveq	r0, r2                                      <== NOT EXECUTED
a0005d30:	0a000010 	beq	a0005d78 <IMFS_readlink+0x58>                 <== NOT EXECUTED
a0005d34:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0005d38:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
a0005d3c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0005d40:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
a0005d44:	0a00000b 	beq	a0005d78 <IMFS_readlink+0x58>                 <== NOT EXECUTED
a0005d48:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a0005d4c:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
a0005d50:	ea000003 	b	a0005d64 <IMFS_readlink+0x44>                   <== NOT EXECUTED
a0005d54:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0005d58:	e7d33000 	ldrb	r3, [r3, r0]                                 <== NOT EXECUTED
a0005d5c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0005d60:	0a000004 	beq	a0005d78 <IMFS_readlink+0x58>                 <== NOT EXECUTED
a0005d64:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a0005d68:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
    buf[i] = node->info.sym_link.name[i];                             
a0005d6c:	e7c1300c 	strb	r3, [r1, ip]                                 <== NOT EXECUTED
                                                                      
  node = loc->node_access;                                            
                                                                      
  IMFS_assert( node->type == IMFS_SYM_LINK );                         
                                                                      
  for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
a0005d70:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
a0005d74:	3afffff6 	bcc	a0005d54 <IMFS_readlink+0x34>                 <== NOT EXECUTED
    buf[i] = node->info.sym_link.name[i];                             
                                                                      
  return i;                                                           
}                                                                     
a0005d78:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a0005d7c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0005d80 <IMFS_rename>: rtems_filesystem_location_info_t *old_parent_loc, /* IN */ rtems_filesystem_location_info_t *old_loc, /* IN */ rtems_filesystem_location_info_t *new_parent_loc, /* IN */ const char *new_name /* IN */ ) {
a0005d80:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_jnode_t *the_jnode;                                            
  IMFS_jnode_t *new_parent;                                           
                                                                      
  the_jnode = old_loc->node_access;                                   
a0005d84:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
  rtems_filesystem_location_info_t  *old_parent_loc,  /* IN */        
  rtems_filesystem_location_info_t  *old_loc,         /* IN */        
  rtems_filesystem_location_info_t  *new_parent_loc,  /* IN */        
  const char                        *new_name         /* IN */        
)                                                                     
{                                                                     
a0005d88:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  IMFS_jnode_t *the_jnode;                                            
  IMFS_jnode_t *new_parent;                                           
                                                                      
  the_jnode = old_loc->node_access;                                   
                                                                      
  strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );                
a0005d8c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t  *old_parent_loc,  /* IN */        
  rtems_filesystem_location_info_t  *old_loc,         /* IN */        
  rtems_filesystem_location_info_t  *new_parent_loc,  /* IN */        
  const char                        *new_name         /* IN */        
)                                                                     
{                                                                     
a0005d90:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  IMFS_jnode_t *the_jnode;                                            
  IMFS_jnode_t *new_parent;                                           
                                                                      
  the_jnode = old_loc->node_access;                                   
                                                                      
  strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );                
a0005d94:	e284000c 	add	r0, r4, #12                                   <== NOT EXECUTED
a0005d98:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
a0005d9c:	eb0030d1 	bl	a00120e8 <strncpy>                             <== NOT EXECUTED
                                                                      
  if ( the_jnode->Parent != NULL )                                    
a0005da0:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0005da4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0005da8:	0a000001 	beq	a0005db4 <IMFS_rename+0x34>                   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
a0005dac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005db0:	eb001198 	bl	a000a418 <_Chain_Extract>                      <== NOT EXECUTED
    rtems_chain_extract( (rtems_chain_node *) the_jnode );            
                                                                      
  new_parent = new_parent_loc->node_access;                           
a0005db4:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
a0005db8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0005dbc:	e2830050 	add	r0, r3, #80	; 0x50                            <== NOT EXECUTED
  the_jnode->Parent = new_parent;                                     
a0005dc0:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
a0005dc4:	eb001188 	bl	a000a3ec <_Chain_Append>                       <== NOT EXECUTED
  rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
                                                                      
  /*                                                                  
   * Update the time.                                                 
   */                                                                 
  IMFS_update_ctime( the_jnode );                                     
a0005dc8:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0005dcc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0005dd0:	eb00019c 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a0005dd4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0005dd8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
                                                                      
  /*                                                                  
   * Update the time.                                                 
   */                                                                 
  IMFS_update_ctime( the_jnode );                                     
a0005ddc:	e5843048 	str	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0005de0:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0005de4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000e2ac <IMFS_rmnod>: int IMFS_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) {
a000e2ac:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t *jnode = (IMFS_jnode_t *) pathloc->node_access;        
a000e2b0:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
                                                                      
  IMFS_create_orphan( jnode );                                        
a000e2b4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e2b8:	ebffffcb 	bl	a000e1ec <IMFS_create_orphan>                  <== NOT EXECUTED
  IMFS_check_node_remove( jnode );                                    
a000e2bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e2c0:	ebffffdc 	bl	a000e238 <IMFS_check_node_remove>              <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000e2c4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000e2c8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000e2cc <IMFS_stat>: { IMFS_fs_info_t *fs_info; IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access;
a000e2cc:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
                                                                      
int IMFS_stat(                                                        
  rtems_filesystem_location_info_t *loc,                              
  struct stat                      *buf                               
)                                                                     
{                                                                     
a000e2d0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  IMFS_device_t  *io;                                                 
                                                                      
  the_jnode = loc->node_access;                                       
                                                                      
                                                                      
  switch ( the_jnode->type ) {                                        
a000e2d4:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a000e2d8:	e2422002 	sub	r2, r2, #2                                    <== NOT EXECUTED
a000e2dc:	e3520005 	cmp	r2, #5                                        <== NOT EXECUTED
a000e2e0:	979ff102 	ldrls	pc, [pc, r2, lsl #2]                        <== NOT EXECUTED
a000e2e4:	ea000027 	b	a000e388 <IMFS_stat+0xbc>                       <== NOT EXECUTED
a000e2e8:	a000e374 	.word	0xa000e374                                  <== NOT EXECUTED
a000e2ec:	a000e388 	.word	0xa000e388                                  <== NOT EXECUTED
a000e2f0:	a000e300 	.word	0xa000e300                                  <== NOT EXECUTED
a000e2f4:	a000e39c 	.word	0xa000e39c                                  <== NOT EXECUTED
a000e2f8:	a000e39c 	.word	0xa000e39c                                  <== NOT EXECUTED
a000e2fc:	a000e300 	.word	0xa000e300                                  <== NOT EXECUTED
    case IMFS_SYM_LINK:                                               
      buf->st_size = 0;                                               
      break;                                                          
                                                                      
    case IMFS_FIFO:                                                   
      buf->st_size = 0;                                               
a000e300:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a000e304:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a000e308:	e5814020 	str	r4, [r1, #32]                                 <== NOT EXECUTED
a000e30c:	e5815024 	str	r5, [r1, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The device number of the IMFS is the major number and the minor is the
   * instance.                                                        
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
a000e310:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
a000e314:	e5936030 	ldr	r6, [r3, #48]	; 0x30                          <== NOT EXECUTED
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
  buf->st_ctime = the_jnode->stat_ctime;                              
a000e318:	e5930048 	ldr	r0, [r3, #72]	; 0x48                          <== NOT EXECUTED
   * The device number of the IMFS is the major number and the minor is the
   * instance.                                                        
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
a000e31c:	e5922034 	ldr	r2, [r2, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
a000e320:	e5935038 	ldr	r5, [r3, #56]	; 0x38                          <== NOT EXECUTED
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
a000e324:	e5934040 	ldr	r4, [r3, #64]	; 0x40                          <== NOT EXECUTED
   * The device number of the IMFS is the major number and the minor is the
   * instance.                                                        
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
a000e328:	e5927000 	ldr	r7, [r2]                                      <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
a000e32c:	e3a02cff 	mov	r2, #65280	; 0xff00                           <== NOT EXECUTED
a000e330:	e28220fe 	add	r2, r2, #254	; 0xfe                           <== NOT EXECUTED
  buf->st_ino   = the_jnode->st_ino;                                  
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
a000e334:	e593c044 	ldr	ip, [r3, #68]	; 0x44                          <== NOT EXECUTED
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
a000e338:	e1d383b4 	ldrh	r8, [r3, #52]	; 0x34                         <== NOT EXECUTED
  /*                                                                  
   * The device number of the IMFS is the major number and the minor is the
   * instance.                                                        
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
a000e33c:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
  buf->st_uid   = the_jnode->st_uid;                                  
a000e340:	e1d323bc 	ldrh	r2, [r3, #60]	; 0x3c                         <== NOT EXECUTED
  buf->st_gid   = the_jnode->st_gid;                                  
a000e344:	e1d333be 	ldrh	r3, [r3, #62]	; 0x3e                         <== NOT EXECUTED
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
a000e348:	e1c181b0 	strh	r8, [r1, #16]                                <== NOT EXECUTED
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
  buf->st_mtime = the_jnode->stat_mtime;                              
  buf->st_ctime = the_jnode->stat_ctime;                              
a000e34c:	e5810038 	str	r0, [r1, #56]	; 0x38                          <== NOT EXECUTED
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
  buf->st_uid   = the_jnode->st_uid;                                  
a000e350:	e1c121b2 	strh	r2, [r1, #18]                                <== NOT EXECUTED
  /*                                                                  
   * The device number of the IMFS is the major number and the minor is the
   * instance.                                                        
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
a000e354:	e5817004 	str	r7, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
a000e358:	e1c131b4 	strh	r3, [r1, #20]                                <== NOT EXECUTED
   */                                                                 
  fs_info = loc->mt_entry->fs_info;                                   
  buf->st_dev =                                                       
    rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
                                                                      
  buf->st_mode  = the_jnode->st_mode;                                 
a000e35c:	e581600c 	str	r6, [r1, #12]                                 <== NOT EXECUTED
  buf->st_nlink = the_jnode->st_nlink;                                
  buf->st_ino   = the_jnode->st_ino;                                  
a000e360:	e5815008 	str	r5, [r1, #8]                                  <== NOT EXECUTED
  buf->st_uid   = the_jnode->st_uid;                                  
  buf->st_gid   = the_jnode->st_gid;                                  
                                                                      
  buf->st_atime = the_jnode->stat_atime;                              
a000e364:	e5814028 	str	r4, [r1, #40]	; 0x28                          <== NOT EXECUTED
  buf->st_mtime = the_jnode->stat_mtime;                              
a000e368:	e581c030 	str	ip, [r1, #48]	; 0x30                          <== NOT EXECUTED
  buf->st_ctime = the_jnode->stat_ctime;                              
                                                                      
  return 0;                                                           
a000e36c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a000e370:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  switch ( the_jnode->type ) {                                        
                                                                      
    case IMFS_DEVICE:                                                 
      io           = &the_jnode->info.device;                         
      buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
a000e374:	e593c054 	ldr	ip, [r3, #84]	; 0x54                          <== NOT EXECUTED
a000e378:	e5932050 	ldr	r2, [r3, #80]	; 0x50                          <== NOT EXECUTED
a000e37c:	e581c01c 	str	ip, [r1, #28]                                 <== NOT EXECUTED
a000e380:	e5812018 	str	r2, [r1, #24]                                 <== NOT EXECUTED
      break;                                                          
a000e384:	eaffffe1 	b	a000e310 <IMFS_stat+0x44>                       <== NOT EXECUTED
    case IMFS_FIFO:                                                   
      buf->st_size = 0;                                               
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( ENOTSUP );                
a000e388:	eb000b54 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e38c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
a000e390:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e394:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000e398:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
      buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
    case IMFS_MEMORY_FILE:                                            
      buf->st_size = the_jnode->info.file.size;                       
a000e39c:	e2835050 	add	r5, r3, #80	; 0x50                            <== NOT EXECUTED
a000e3a0:	e8950030 	ldm	r5, {r4, r5}                                  <== NOT EXECUTED
a000e3a4:	e5814020 	str	r4, [r1, #32]                                 <== NOT EXECUTED
a000e3a8:	e5815024 	str	r5, [r1, #36]	; 0x24                          <== NOT EXECUTED
      break;                                                          
a000e3ac:	eaffffd7 	b	a000e310 <IMFS_stat+0x44>                       <== NOT EXECUTED
                                                                      

a0005de8 <IMFS_symlink>: int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) {
a0005de8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a0005dec:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0005df0:	e24dd040 	sub	sp, sp, #64	; 0x40                            <== NOT EXECUTED
  int                i;                                               
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
a0005df4:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
int IMFS_symlink(                                                     
  rtems_filesystem_location_info_t  *parent_loc,                      
  const char                        *link_name,                       
  const char                        *node_name                        
)                                                                     
{                                                                     
a0005df8:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
a0005dfc:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  int                i;                                               
                                                                      
  /*                                                                  
   * Remove any separators at the end of the string.                  
   */                                                                 
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
a0005e00:	eb0030a0 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a0005e04:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0005e08:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0005e0c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005e10:	e28d303c 	add	r3, sp, #60	; 0x3c                            <== NOT EXECUTED
a0005e14:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0005e18:	eb0020bf 	bl	a000e11c <IMFS_get_token>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Duplicate link name                                              
   */                                                                 
  info.sym_link.name = strdup(link_name);                             
a0005e1c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0005e20:	eb003084 	bl	a0012038 <strdup>                              <== NOT EXECUTED
  if (info.sym_link.name == NULL) {                                   
a0005e24:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  IMFS_get_token( node_name, strlen( node_name ), new_name, &i );     
                                                                      
  /*                                                                  
   * Duplicate link name                                              
   */                                                                 
  info.sym_link.name = strdup(link_name);                             
a0005e28:	e58d0028 	str	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
  if (info.sym_link.name == NULL) {                                   
a0005e2c:	0a00000e 	beq	a0005e6c <IMFS_symlink+0x84>                  <== NOT EXECUTED
   *        was ONLY passed a NULL when we created the root node.  We 
   *        added a new IMFS_create_root_node() so this path no longer
   *        existed.  The result was simpler code which should not have
   *        this path.                                                
   */                                                                 
  new_node = IMFS_create_node(                                        
a0005e30:	e28d2028 	add	r2, sp, #40	; 0x28                            <== NOT EXECUTED
a0005e34:	e3a03ca2 	mov	r3, #41472	; 0xa200                           <== NOT EXECUTED
a0005e38:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0005e3c:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
a0005e40:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005e44:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005e48:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0005e4c:	eb001e16 	bl	a000d6ac <IMFS_create_node>                    <== NOT EXECUTED
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if (new_node == NULL) {                                             
a0005e50:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    free(info.sym_link.name);                                         
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
  }                                                                   
                                                                      
  return 0;                                                           
a0005e54:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
    new_name,                                                         
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if (new_node == NULL) {                                             
a0005e58:	0a000001 	beq	a0005e64 <IMFS_symlink+0x7c>                  <== NOT EXECUTED
    free(info.sym_link.name);                                         
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a0005e5c:	e28dd040 	add	sp, sp, #64	; 0x40                            <== NOT EXECUTED
a0005e60:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),                     
    &info                                                             
  );                                                                  
                                                                      
  if (new_node == NULL) {                                             
    free(info.sym_link.name);                                         
a0005e64:	e59d0028 	ldr	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
a0005e68:	eb000141 	bl	a0006374 <free>                                <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(ENOMEM);                     
a0005e6c:	eb002c9b 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005e70:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0005e74:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005e78:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005e7c:	eafffff6 	b	a0005e5c <IMFS_symlink+0x74>                    <== NOT EXECUTED
                                                                      

a0005e80 <IMFS_unlink>: int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) {
a0005e80:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  IMFS_jnode_t                      *node;                            
  rtems_filesystem_location_info_t   the_link;                        
  int                                result = 0;                      
                                                                      
  node = loc->node_access;                                            
a0005e84:	e5915000 	ldr	r5, [r1]                                      <== NOT EXECUTED
                                                                      
int IMFS_unlink(                                                      
  rtems_filesystem_location_info_t  *parentloc, /* IN */              
  rtems_filesystem_location_info_t  *loc        /* IN */              
)                                                                     
{                                                                     
a0005e88:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a0005e8c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  /*                                                                  
   * If this is the last last pointer to the node                     
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
a0005e90:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          <== NOT EXECUTED
                                                                      
int IMFS_unlink(                                                      
  rtems_filesystem_location_info_t  *parentloc, /* IN */              
  rtems_filesystem_location_info_t  *loc        /* IN */              
)                                                                     
{                                                                     
a0005e94:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  /*                                                                  
   * If this is the last last pointer to the node                     
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
a0005e98:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a0005e9c:	0a000006 	beq	a0005ebc <IMFS_unlink+0x3c>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now actually free the node we were asked to free.               
   */                                                                 
                                                                      
  result = (*loc->handlers->rmnod_h)( parentloc, loc );               
a0005ea0:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0005ea4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005ea8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0005eac:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0005eb0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a0005eb4:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a0005eb8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
   * free the node.                                                   
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
                                                                      
    if ( !node->info.hard_link.link_node )                            
a0005ebc:	e595e050 	ldr	lr, [r5, #80]	; 0x50                          <== NOT EXECUTED
a0005ec0:	e35e0000 	cmp	lr, #0                                        <== NOT EXECUTED
a0005ec4:	0a00001f 	beq	a0005f48 <IMFS_unlink+0xc8>                   <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    the_link = *loc;                                                  
a0005ec8:	e1a0c00d 	mov	ip, sp                                        <== NOT EXECUTED
a0005ecc:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
a0005ed0:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0005ed4:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0005ed8:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
    the_link.node_access = node->info.hard_link.link_node;            
a0005edc:	e28d801c 	add	r8, sp, #28                                   <== NOT EXECUTED
    IMFS_Set_handlers( &the_link );                                   
a0005ee0:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
  if ( node->type == IMFS_HARD_LINK ) {                               
                                                                      
    if ( !node->info.hard_link.link_node )                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    the_link = *loc;                                                  
a0005ee4:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
    the_link.node_access = node->info.hard_link.link_node;            
a0005ee8:	e528e01c 	str	lr, [r8, #-28]!                               <== NOT EXECUTED
    IMFS_Set_handlers( &the_link );                                   
a0005eec:	eb001e52 	bl	a000d83c <IMFS_Set_handlers>                   <== NOT EXECUTED
    /*                                                                
     *  If removing the last hard link to a node, then we need        
     *  to remove the node that is a link and the node itself.        
     */                                                               
                                                                      
    if ( node->info.hard_link.link_node->st_nlink == 1)               
a0005ef0:	e5953050 	ldr	r3, [r5, #80]	; 0x50                          <== NOT EXECUTED
a0005ef4:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
a0005ef8:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
a0005efc:	0a000008 	beq	a0005f24 <IMFS_unlink+0xa4>                   <== NOT EXECUTED
        if ( result != 0 )                                            
            return -1;                                                
    }                                                                 
    else                                                              
    {                                                                 
        node->info.hard_link.link_node->st_nlink --;                  
a0005f00:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a0005f04:	e1c323b4 	strh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
        IMFS_update_ctime( node->info.hard_link.link_node );          
a0005f08:	e28d0014 	add	r0, sp, #20                                   <== NOT EXECUTED
a0005f0c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0005f10:	eb00014c 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a0005f14:	e5953050 	ldr	r3, [r5, #80]	; 0x50                          <== NOT EXECUTED
a0005f18:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
a0005f1c:	e5832048 	str	r2, [r3, #72]	; 0x48                          <== NOT EXECUTED
a0005f20:	eaffffde 	b	a0005ea0 <IMFS_unlink+0x20>                     <== NOT EXECUTED
     *  to remove the node that is a link and the node itself.        
     */                                                               
                                                                      
    if ( node->info.hard_link.link_node->st_nlink == 1)               
    {                                                                 
        result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
a0005f24:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0005f28:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005f2c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0005f30:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0005f34:	e12fff33 	blx	r3                                            <== NOT EXECUTED
        if ( result != 0 )                                            
a0005f38:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0005f3c:	0affffd7 	beq	a0005ea0 <IMFS_unlink+0x20>                   <== NOT EXECUTED
            return -1;                                                
a0005f40:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005f44:	eaffffda 	b	a0005eb4 <IMFS_unlink+0x34>                     <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( node->type == IMFS_HARD_LINK ) {                               
                                                                      
    if ( !node->info.hard_link.link_node )                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0005f48:	eb002c64 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005f4c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0005f50:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005f54:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005f58:	eaffffd5 	b	a0005eb4 <IMFS_unlink+0x34>                     <== NOT EXECUTED
                                                                      

a0005f5c <IMFS_unmount>: rtems_filesystem_mount_table_entry_t *mt_entry ) { IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access;
a0005f5c:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int IMFS_unmount(                                                     
  rtems_filesystem_mount_table_entry_t *mt_entry                      
)                                                                     
{                                                                     
a0005f60:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Is the node that we are mounting onto a directory node ?         
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
a0005f64:	e593204c 	ldr	r2, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a0005f68:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
a0005f6c:	1a000005 	bne	a0005f88 <IMFS_unmount+0x2c>                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Did the node indicate that there was a directory mounted here?   
   */                                                                 
                                                                      
  if ( node->info.directory.mt_fs == NULL )                           
a0005f70:	e593205c 	ldr	r2, [r3, #92]	; 0x5c                          <== NOT EXECUTED
a0005f74:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0005f78:	0a000007 	beq	a0005f9c <IMFS_unmount+0x40>                  <== NOT EXECUTED
  /*                                                                  
   * Set the mt_fs pointer to indicate that there is no longer        
   * a file system mounted to this point.                             
   */                                                                 
                                                                      
  node->info.directory.mt_fs = NULL;                                  
a0005f7c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0005f80:	e583005c 	str	r0, [r3, #92]	; 0x5c                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0005f84:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  /*                                                                  
   * Is the node that we are mounting onto a directory node ?         
   */                                                                 
                                                                      
  if ( node->type != IMFS_DIRECTORY )                                 
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a0005f88:	eb002c54 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005f8c:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a0005f90:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005f94:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005f98:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  /*                                                                  
   * Did the node indicate that there was a directory mounted here?   
   */                                                                 
                                                                      
  if ( node->info.directory.mt_fs == NULL )                           
    rtems_set_errno_and_return_minus_one( EINVAL );  /* XXX */        
a0005f9c:	eb002c4f 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0005fa0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0005fa4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005fa8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005fac:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0005fb0 <IMFS_utime>: int IMFS_utime( rtems_filesystem_location_info_t *pathloc, /* IN */ time_t actime, /* IN */ time_t modtime /* IN */ ) {
a0005fb0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
a0005fb4:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
                                                                      
  the_jnode->stat_atime = actime;                                     
  the_jnode->stat_mtime = modtime;                                    
  the_jnode->stat_ctime = time( NULL );                               
a0005fb8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
{                                                                     
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
                                                                      
  the_jnode->stat_atime = actime;                                     
a0005fbc:	e5841040 	str	r1, [r4, #64]	; 0x40                          <== NOT EXECUTED
  the_jnode->stat_mtime = modtime;                                    
a0005fc0:	e5842044 	str	r2, [r4, #68]	; 0x44                          <== NOT EXECUTED
  the_jnode->stat_ctime = time( NULL );                               
a0005fc4:	eb003082 	bl	a00121d4 <time>                                <== NOT EXECUTED
a0005fc8:	e5840048 	str	r0, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0005fcc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0005fd0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0006620 <RTEMS_Malloc_Initialize>: ) { /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers != NULL ) {
a0006620:	e59f30d0 	ldr	r3, [pc, #208]	; a00066f8 <RTEMS_Malloc_Initialize+0xd8>
void RTEMS_Malloc_Initialize(                                         
  void *heap_begin,                                                   
  uintptr_t heap_size,                                                
  size_t sbrk_amount                                                  
)                                                                     
{                                                                     
a0006624:	e92d4070 	push	{r4, r5, r6, lr}                             
  /*                                                                  
   *  If configured, initialize the statistics support                
  */                                                                  
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
a0006628:	e5933000 	ldr	r3, [r3]                                      
void RTEMS_Malloc_Initialize(                                         
  void *heap_begin,                                                   
  uintptr_t heap_size,                                                
  size_t sbrk_amount                                                  
)                                                                     
{                                                                     
a000662c:	e1a05000 	mov	r5, r0                                        
a0006630:	e1a06001 	mov	r6, r1                                        
  /*                                                                  
   *  If configured, initialize the statistics support                
  */                                                                  
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
a0006634:	e3530000 	cmp	r3, #0                                        
void RTEMS_Malloc_Initialize(                                         
  void *heap_begin,                                                   
  uintptr_t heap_size,                                                
  size_t sbrk_amount                                                  
)                                                                     
{                                                                     
a0006638:	e1a04002 	mov	r4, r2                                        
  /*                                                                  
   *  If configured, initialize the statistics support                
  */                                                                  
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
a000663c:	0a000001 	beq	a0006648 <RTEMS_Malloc_Initialize+0x28>       
    (*rtems_malloc_statistics_helpers->initialize)();                 
a0006640:	e5933000 	ldr	r3, [r3]                                      
a0006644:	e12fff33 	blx	r3                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize the garbage collection list to start with nothing on it.
   */                                                                 
  malloc_deferred_frees_initialize();                                 
a0006648:	ebffffe0 	bl	a00065d0 <malloc_deferred_frees_initialize>    
                                                                      
  /*                                                                  
   *  Initialize the optional sbrk support for extending the heap     
   */                                                                 
  if ( rtems_malloc_sbrk_helpers != NULL ) {                          
a000664c:	e59f30a8 	ldr	r3, [pc, #168]	; a00066fc <RTEMS_Malloc_Initialize+0xdc>
a0006650:	e5933000 	ldr	r3, [r3]                                      
a0006654:	e3530000 	cmp	r3, #0                                        
a0006658:	0a000005 	beq	a0006674 <RTEMS_Malloc_Initialize+0x54>       
    heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(            
a000665c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0006660:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006664:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006668:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      heap_begin,                                                     
      sbrk_amount                                                     
    );                                                                
    heap_size  = (uintptr_t) sbrk_amount;                             
a000666c:	e1a06004 	mov	r6, r4                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the optional sbrk support for extending the heap     
   */                                                                 
  if ( rtems_malloc_sbrk_helpers != NULL ) {                          
    heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(            
a0006670:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   *  of the time under UNIX because zero'ing memory when it is first 
   *  given to a process eliminates the chance of a process seeing data
   *  left over from another process.  This would be a security violation.
   */                                                                 
                                                                      
  if (                                                                
a0006674:	e59f4084 	ldr	r4, [pc, #132]	; a0006700 <RTEMS_Malloc_Initialize+0xe0>
a0006678:	e5d41000 	ldrb	r1, [r4]                                     
a000667c:	e3510000 	cmp	r1, #0                                        
a0006680:	1a000018 	bne	a00066e8 <RTEMS_Malloc_Initialize+0xc8>       
    !rtems_unified_work_area                                          
      && rtems_configuration_get_do_zero_of_workspace()               
a0006684:	e59f3078 	ldr	r3, [pc, #120]	; a0006704 <RTEMS_Malloc_Initialize+0xe4>
a0006688:	e5d33028 	ldrb	r3, [r3, #40]	; 0x28                         
a000668c:	e3530000 	cmp	r3, #0                                        
a0006690:	1a00000e 	bne	a00066d0 <RTEMS_Malloc_Initialize+0xb0>       
  void *area_begin,                                                   
  uintptr_t area_size,                                                
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return _Heap_Initialize( heap, area_begin, area_size, page_size );  
a0006694:	e59f406c 	ldr	r4, [pc, #108]	; a0006708 <RTEMS_Malloc_Initialize+0xe8>
a0006698:	e1a01005 	mov	r1, r5                                        
a000669c:	e1a02006 	mov	r2, r6                                        
a00066a0:	e5940000 	ldr	r0, [r4]                                      
a00066a4:	e3a03008 	mov	r3, #8                                        
a00066a8:	eb00110f 	bl	a000aaec <_Heap_Initialize>                    
      RTEMS_Malloc_Heap,                                              
      heap_begin,                                                     
      heap_size,                                                      
      CPU_HEAP_ALIGNMENT                                              
    );                                                                
    if ( status == 0 ) {                                              
a00066ac:	e3500000 	cmp	r0, #0                                        
a00066b0:	0a00000e 	beq	a00066f0 <RTEMS_Malloc_Initialize+0xd0>       
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
    }                                                                 
  }                                                                   
                                                                      
  MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
a00066b4:	e59f5050 	ldr	r5, [pc, #80]	; a000670c <RTEMS_Malloc_Initialize+0xec>
a00066b8:	e5940000 	ldr	r0, [r4]                                      
a00066bc:	e5954000 	ldr	r4, [r5]                                      
a00066c0:	eb0013be 	bl	a000b5c0 <_Protected_heap_Get_size>            
a00066c4:	e0800004 	add	r0, r0, r4                                    
a00066c8:	e5850000 	str	r0, [r5]                                      
}                                                                     
a00066cc:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      
  if (                                                                
    !rtems_unified_work_area                                          
      && rtems_configuration_get_do_zero_of_workspace()               
  ) {                                                                 
     memset( heap_begin, 0, heap_size );                              
a00066d0:	e1a00005 	mov	r0, r5                                        
a00066d4:	e1a02006 	mov	r2, r6                                        
a00066d8:	eb002ce5 	bl	a0011a74 <memset>                              
   *  Unfortunately we cannot use assert if this fails because if this
   *  has failed we do not have a heap and if we do not have a heap   
   *  STDIO cannot work because there will be no buffers.             
   */                                                                 
                                                                      
  if ( !rtems_unified_work_area ) {                                   
a00066dc:	e5d43000 	ldrb	r3, [r4]                                     
a00066e0:	e3530000 	cmp	r3, #0                                        
a00066e4:	0affffea 	beq	a0006694 <RTEMS_Malloc_Initialize+0x74>       
a00066e8:	e59f4018 	ldr	r4, [pc, #24]	; a0006708 <RTEMS_Malloc_Initialize+0xe8>
a00066ec:	eafffff0 	b	a00066b4 <RTEMS_Malloc_Initialize+0x94>         
      heap_begin,                                                     
      heap_size,                                                      
      CPU_HEAP_ALIGNMENT                                              
    );                                                                
    if ( status == 0 ) {                                              
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
a00066f0:	e280001a 	add	r0, r0, #26                                   <== NOT EXECUTED
a00066f4:	eb000e83 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0005714 <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
a0005714:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
a0005718:	e59030b8 	ldr	r3, [r0, #184]	; 0xb8                         <== NOT EXECUTED
  size = Stack_check_usable_stack_size(stack);                        
a000571c:	e59060b4 	ldr	r6, [r0, #180]	; 0xb4                         <== NOT EXECUTED
static rtems_printk_plugin_t   print_handler;                         
                                                                      
void Stack_check_Dump_threads_usage(                                  
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a0005720:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
a0005724:	e283c010 	add	ip, r3, #16                                   <== NOT EXECUTED
  size = Stack_check_usable_stack_size(stack);                        
a0005728:	e2466010 	sub	r6, r6, #16                                   <== NOT EXECUTED
    /*                                                                
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
a000572c:	e28cb010 	add	fp, ip, #16                                   <== NOT EXECUTED
    for (ebase = base + length; base < ebase; base++)                 
a0005730:	e3c61003 	bic	r1, r6, #3                                    <== NOT EXECUTED
a0005734:	e08b1001 	add	r1, fp, r1                                    <== NOT EXECUTED
a0005738:	e15b0001 	cmp	fp, r1                                        <== NOT EXECUTED
static rtems_printk_plugin_t   print_handler;                         
                                                                      
void Stack_check_Dump_threads_usage(                                  
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a000573c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
      current = 0;                                                    
    } else                                                            
  #endif                                                              
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
a0005740:	e59090e4 	ldr	r9, [r0, #228]	; 0xe4                         <== NOT EXECUTED
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
a0005744:	2a00000b 	bcs	a0005778 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
a0005748:	e59c0010 	ldr	r0, [ip, #16]                                 <== NOT EXECUTED
a000574c:	e59f20cc 	ldr	r2, [pc, #204]	; a0005820 <Stack_check_Dump_threads_usage+0x10c><== NOT EXECUTED
a0005750:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
 *  Try to print out how much stack was actually used by the task.    
 */                                                                   
static void                   *print_context;                         
static rtems_printk_plugin_t   print_handler;                         
                                                                      
void Stack_check_Dump_threads_usage(                                  
a0005754:	02833024 	addeq	r3, r3, #36	; 0x24                          <== NOT EXECUTED
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
      if (*base != U32_PATTERN)                                       
a0005758:	0a000003 	beq	a000576c <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED
a000575c:	ea000026 	b	a00057fc <Stack_check_Dump_threads_usage+0xe8>  <== NOT EXECUTED
a0005760:	e4932004 	ldr	r2, [r3], #4                                  <== NOT EXECUTED
a0005764:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
a0005768:	1a000023 	bne	a00057fc <Stack_check_Dump_threads_usage+0xe8><== NOT EXECUTED
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
a000576c:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
a0005770:	e1a0b003 	mov	fp, r3                                        <== NOT EXECUTED
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
a0005774:	8afffff9 	bhi	a0005760 <Stack_check_Dump_threads_usage+0x4c><== NOT EXECUTED
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
                                                                      
  if ( high_water_mark )                                              
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
  else                                                                
    used = 0;                                                         
a0005778:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
  #endif                                                              
    {                                                                 
      (*print_handler)(                                               
a000577c:	e5958008 	ldr	r8, [r5, #8]                                  <== NOT EXECUTED
a0005780:	e59f409c 	ldr	r4, [pc, #156]	; a0005824 <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
a0005784:	e3a01005 	mov	r1, #5                                        <== NOT EXECUTED
a0005788:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a000578c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0005790:	e8940480 	ldm	r4, {r7, sl}                                  <== NOT EXECUTED
a0005794:	eb00103f 	bl	a0009898 <rtems_object_get_name>               <== NOT EXECUTED
a0005798:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a000579c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a00057a0:	e59f1080 	ldr	r1, [pc, #128]	; a0005828 <Stack_check_Dump_threads_usage+0x114><== NOT EXECUTED
a00057a4:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a00057a8:	e12fff37 	blx	r7                                            <== NOT EXECUTED
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
a00057ac:	e59530b4 	ldr	r3, [r5, #180]	; 0xb4                         <== NOT EXECUTED
a00057b0:	e59520b8 	ldr	r2, [r5, #184]	; 0xb8                         <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
a00057b4:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
a00057b8:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
a00057bc:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
a00057c0:	e59f1064 	ldr	r1, [pc, #100]	; a000582c <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
a00057c4:	e58d9000 	str	r9, [sp]                                      <== NOT EXECUTED
a00057c8:	e58d6004 	str	r6, [sp, #4]                                  <== NOT EXECUTED
a00057cc:	e594c000 	ldr	ip, [r4]                                      <== NOT EXECUTED
a00057d0:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
a00057d4:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a00057d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00057dc:	0a00000a 	beq	a000580c <Stack_check_Dump_threads_usage+0xf8><== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
a00057e0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00057e4:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
a00057e8:	e59f1040 	ldr	r1, [pc, #64]	; a0005830 <Stack_check_Dump_threads_usage+0x11c><== NOT EXECUTED
a00057ec:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a00057f0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  }                                                                   
                                                                      
                                                                      
}                                                                     
a00057f4:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a00057f8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  low  = Stack_check_usable_stack_start(stack);                       
  size = Stack_check_usable_stack_size(stack);                        
                                                                      
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
                                                                      
  if ( high_water_mark )                                              
a00057fc:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
a0005800:	108cc006 	addne	ip, ip, r6                                  <== NOT EXECUTED
a0005804:	106bb00c 	rsbne	fp, fp, ip                                  <== NOT EXECUTED
a0005808:	eaffffdb 	b	a000577c <Stack_check_Dump_threads_usage+0x68>  <== NOT EXECUTED
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
    (*print_handler)( print_context, "Unavailable\n" );               
a000580c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a0005810:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
a0005814:	e59f1018 	ldr	r1, [pc, #24]	; a0005834 <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED
a0005818:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000581c:	eafffff4 	b	a00057f4 <Stack_check_Dump_threads_usage+0xe0>  <== NOT EXECUTED
                                                                      

a00058e8 <Stack_check_report_blown_task>: Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) {
a00058e8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00058ec:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a00058f0:	e24dd020 	sub	sp, sp, #32                                   <== NOT EXECUTED
  Stack_Control *stack = &running->Start.Initial_stack;               
  void          *pattern_area = Stack_check_Get_pattern(stack);       
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
a00058f4:	e59f0084 	ldr	r0, [pc, #132]	; a0005980 <Stack_check_report_blown_task+0x98><== NOT EXECUTED
  Thread_Control *running,                                            
  bool pattern_ok                                                     
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;                                 
                                                                      
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{                                                                     
a00058f8:	e20140ff 	and	r4, r1, #255	; 0xff                           <== NOT EXECUTED
  Stack_Control *stack = &running->Start.Initial_stack;               
  void          *pattern_area = Stack_check_Get_pattern(stack);       
a00058fc:	e59650b8 	ldr	r5, [r6, #184]	; 0xb8                         <== NOT EXECUTED
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
a0005900:	eb000676 	bl	a00072e0 <printk>                              <== NOT EXECUTED
  printk("task control block: 0x%08" PRIxPTR "\n", running);          
a0005904:	e59f0078 	ldr	r0, [pc, #120]	; a0005984 <Stack_check_report_blown_task+0x9c><== NOT EXECUTED
a0005908:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000590c:	eb000673 	bl	a00072e0 <printk>                              <== NOT EXECUTED
  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);   
a0005910:	e59f0070 	ldr	r0, [pc, #112]	; a0005988 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED
a0005914:	e5961008 	ldr	r1, [r6, #8]                                  <== NOT EXECUTED
a0005918:	eb000670 	bl	a00072e0 <printk>                              <== NOT EXECUTED
  printk(                                                             
a000591c:	e59f0068 	ldr	r0, [pc, #104]	; a000598c <Stack_check_report_blown_task+0xa4><== NOT EXECUTED
a0005920:	e596100c 	ldr	r1, [r6, #12]                                 <== NOT EXECUTED
a0005924:	eb00066d 	bl	a00072e0 <printk>                              <== NOT EXECUTED
    "task name: 0x%08" PRIx32 "\n",                                   
    running->Object.name.name_u32                                     
  );                                                                  
  printk(                                                             
a0005928:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000592c:	e3a01020 	mov	r1, #32                                       <== NOT EXECUTED
a0005930:	e5960008 	ldr	r0, [r6, #8]                                  <== NOT EXECUTED
a0005934:	eb000fd7 	bl	a0009898 <rtems_object_get_name>               <== NOT EXECUTED
a0005938:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000593c:	e59f004c 	ldr	r0, [pc, #76]	; a0005990 <Stack_check_report_blown_task+0xa8><== NOT EXECUTED
a0005940:	eb000666 	bl	a00072e0 <printk>                              <== NOT EXECUTED
  );                                                                  
  printk(                                                             
    "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
a0005944:	e59620b8 	ldr	r2, [r6, #184]	; 0xb8                         <== NOT EXECUTED
a0005948:	e59610b4 	ldr	r1, [r6, #180]	; 0xb4                         <== NOT EXECUTED
  );                                                                  
  printk(                                                             
    "task name string: %s\n",                                         
    rtems_object_get_name(running->Object.id, sizeof(name), name)     
  );                                                                  
  printk(                                                             
a000594c:	e59f0040 	ldr	r0, [pc, #64]	; a0005994 <Stack_check_report_blown_task+0xac><== NOT EXECUTED
a0005950:	e0823001 	add	r3, r2, r1                                    <== NOT EXECUTED
a0005954:	eb000661 	bl	a00072e0 <printk>                              <== NOT EXECUTED
    "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
  );                                                                  
  if (!pattern_ok) {                                                  
a0005958:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000595c:	0a000001 	beq	a0005968 <Stack_check_report_blown_task+0x80> <== NOT EXECUTED
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal_error_occurred(0x81);                                   
a0005960:	e3a00081 	mov	r0, #129	; 0x81                               <== NOT EXECUTED
a0005964:	eb0011f6 	bl	a000a144 <rtems_fatal_error_occurred>          <== NOT EXECUTED
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
  );                                                                  
  if (!pattern_ok) {                                                  
    printk(                                                           
a0005968:	e59f0028 	ldr	r0, [pc, #40]	; a0005998 <Stack_check_report_blown_task+0xb0><== NOT EXECUTED
a000596c:	e3a01010 	mov	r1, #16                                       <== NOT EXECUTED
a0005970:	e2852008 	add	r2, r5, #8                                    <== NOT EXECUTED
a0005974:	e2853018 	add	r3, r5, #24                                   <== NOT EXECUTED
a0005978:	eb000658 	bl	a00072e0 <printk>                              <== NOT EXECUTED
a000597c:	eafffff7 	b	a0005960 <Stack_check_report_blown_task+0x78>   <== NOT EXECUTED
                                                                      

a000ff40 <TOD_MICROSECONDS_TO_TICKS>: uint32_t TOD_MICROSECONDS_TO_TICKS( uint32_t microseconds ) { return (microseconds / rtems_configuration_get_microseconds_per_tick());
a000ff40:	e59f300c 	ldr	r3, [pc, #12]	; a000ff54 <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>                                          
                                                                      
uint32_t TOD_MICROSECONDS_TO_TICKS(                                   
  uint32_t microseconds                                               
)                                                                     
{                                                                     
a000ff44:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  return (microseconds / rtems_configuration_get_microseconds_per_tick());
a000ff48:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
a000ff4c:	eb004e6e 	bl	a002390c <__aeabi_uidiv>                       <== NOT EXECUTED
}                                                                     
a000ff50:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000b610 <TOD_MILLISECONDS_TO_TICKS>: uint32_t TOD_MILLISECONDS_TO_TICKS( uint32_t milliseconds ) { return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
a000b610:	e59f3018 	ldr	r3, [pc, #24]	; a000b630 <TOD_MILLISECONDS_TO_TICKS+0x20><== NOT EXECUTED
#include <rtems/score/tod.h>                                          
                                                                      
uint32_t TOD_MILLISECONDS_TO_TICKS(                                   
  uint32_t milliseconds                                               
)                                                                     
{                                                                     
a000b614:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
a000b618:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
a000b61c:	e59f3010 	ldr	r3, [pc, #16]	; a000b634 <TOD_MILLISECONDS_TO_TICKS+0x24><== NOT EXECUTED
a000b620:	e0812193 	umull	r2, r1, r3, r1                              <== NOT EXECUTED
a000b624:	e1a01321 	lsr	r1, r1, #6                                    <== NOT EXECUTED
a000b628:	eb00409d 	bl	a001b8a4 <__aeabi_uidiv>                       <== NOT EXECUTED
}                                                                     
a000b62c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0021c50 <TOD_TICKS_PER_SECOND_method>: #include <rtems/config.h> #include <rtems/score/tod.h> uint32_t TOD_TICKS_PER_SECOND_method(void) { return (TOD_MICROSECONDS_PER_SECOND /
a0021c50:	e59f3014 	ldr	r3, [pc, #20]	; a0021c6c <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED
a0021c54:	e3a0093d 	mov	r0, #999424	; 0xf4000                         <== NOT EXECUTED
#include <rtems/system.h>                                             
#include <rtems/config.h>                                             
#include <rtems/score/tod.h>                                          
                                                                      
uint32_t TOD_TICKS_PER_SECOND_method(void)                            
{                                                                     
a0021c58:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  return (TOD_MICROSECONDS_PER_SECOND /                               
a0021c5c:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
a0021c60:	e2800d09 	add	r0, r0, #576	; 0x240                          <== NOT EXECUTED
a0021c64:	ebfff604 	bl	a001f47c <__aeabi_uidiv>                       <== NOT EXECUTED
      rtems_configuration_get_microseconds_per_tick());               
}                                                                     
a0021c68:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0012cb4 <_Barrier_Translate_core_barrier_return_code>: */ #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Barrier_Translate_core_barrier_return_code_[the_barrier_status];
a0012cb4:	e59f3004 	ldr	r3, [pc, #4]	; a0012cc0 <_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED
}                                                                     
a0012cb8:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a0012cbc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0012230 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) {
a0012230:	e92d0030 	push	{r4, r5}                                     <== NOT EXECUTED
                                                                      
  the_barrier->Attributes                = *the_barrier_attributes;   
a0012234:	e8910030 	ldm	r1, {r4, r5}                                  <== NOT EXECUTED
  the_barrier->number_of_waiting_threads = 0;                         
a0012238:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a001223c:	e5803048 	str	r3, [r0, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  _Thread_queue_Initialize(                                           
a0012240:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0012244:	e3a02801 	mov	r2, #65536	; 0x10000                          <== NOT EXECUTED
a0012248:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
  CORE_barrier_Control       *the_barrier,                            
  CORE_barrier_Attributes    *the_barrier_attributes                  
)                                                                     
{                                                                     
                                                                      
  the_barrier->Attributes                = *the_barrier_attributes;   
a001224c:	e5804040 	str	r4, [r0, #64]	; 0x40                          <== NOT EXECUTED
a0012250:	e5805044 	str	r5, [r0, #68]	; 0x44                          <== NOT EXECUTED
    &the_barrier->Wait_queue,                                         
    THREAD_QUEUE_DISCIPLINE_FIFO,                                     
    STATES_WAITING_FOR_BARRIER,                                       
    CORE_BARRIER_TIMEOUT                                              
  );                                                                  
}                                                                     
a0012254:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
{                                                                     
                                                                      
  the_barrier->Attributes                = *the_barrier_attributes;   
  the_barrier->number_of_waiting_threads = 0;                         
                                                                      
  _Thread_queue_Initialize(                                           
a0012258:	eafff16c 	b	a000e810 <_Thread_queue_Initialize>             <== NOT EXECUTED
                                                                      

a001225c <_CORE_barrier_Release>: #else Objects_Id id __attribute__((unused)), CORE_barrier_API_mp_support_callout api_barrier_mp_support __attribute__((unused)) #endif ) {
a001225c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0012260:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  Thread_Control *the_thread;                                         
  uint32_t        count;                                              
                                                                      
  count = 0;                                                          
a0012264:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
  while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
a0012268:	ea000000 	b	a0012270 <_CORE_barrier_Release+0x14>           <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_barrier_mp_support) ( the_thread, id );                   
#endif                                                                
    count++;                                                          
a001226c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
{                                                                     
  Thread_Control *the_thread;                                         
  uint32_t        count;                                              
                                                                      
  count = 0;                                                          
  while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
a0012270:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0012274:	ebfff059 	bl	a000e3e0 <_Thread_queue_Dequeue>               <== NOT EXECUTED
a0012278:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a001227c:	1afffffa 	bne	a001226c <_CORE_barrier_Release+0x10>         <== NOT EXECUTED
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_barrier_mp_support) ( the_thread, id );                   
#endif                                                                
    count++;                                                          
  }                                                                   
  the_barrier->number_of_waiting_threads = 0;                         
a0012280:	e5850048 	str	r0, [r5, #72]	; 0x48                          <== NOT EXECUTED
  return count;                                                       
}                                                                     
a0012284:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0012288:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a001228c <_CORE_barrier_Wait>: ) { Thread_Control *executing; ISR_Level level; executing = _Thread_Executing;
a001228c:	e59fc078 	ldr	ip, [pc, #120]	; a001230c <_CORE_barrier_Wait+0x80><== NOT EXECUTED
  Objects_Id                           id,                            
  bool                                 wait,                          
  Watchdog_Interval                    timeout,                       
  CORE_barrier_API_mp_support_callout  api_barrier_mp_support         
)                                                                     
{                                                                     
a0012290:	e92d0070 	push	{r4, r5, r6}                                 <== NOT EXECUTED
  Thread_Control *executing;                                          
  ISR_Level       level;                                              
                                                                      
  executing = _Thread_Executing;                                      
a0012294:	e59cc004 	ldr	ip, [ip, #4]                                  <== NOT EXECUTED
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;       
a0012298:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
  Objects_Id                           id,                            
  bool                                 wait,                          
  Watchdog_Interval                    timeout,                       
  CORE_barrier_API_mp_support_callout  api_barrier_mp_support         
)                                                                     
{                                                                     
a001229c:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
  Thread_Control *executing;                                          
  ISR_Level       level;                                              
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;       
a00122a0:	e58c4034 	str	r4, [ip, #52]	; 0x34                          <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a00122a4:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a00122a8:	e3864080 	orr	r4, r6, #128	; 0x80                           <== NOT EXECUTED
a00122ac:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
  _ISR_Disable( level );                                              
  the_barrier->number_of_waiting_threads++;                           
a00122b0:	e5904048 	ldr	r4, [r0, #72]	; 0x48                          <== NOT EXECUTED
  if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {     
a00122b4:	e5905040 	ldr	r5, [r0, #64]	; 0x40                          <== NOT EXECUTED
  ISR_Level       level;                                              
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;       
  _ISR_Disable( level );                                              
  the_barrier->number_of_waiting_threads++;                           
a00122b8:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
  if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {     
a00122bc:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
  ISR_Level       level;                                              
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;       
  _ISR_Disable( level );                                              
  the_barrier->number_of_waiting_threads++;                           
a00122c0:	e5804048 	str	r4, [r0, #72]	; 0x48                          <== NOT EXECUTED
  if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {     
a00122c4:	1a000002 	bne	a00122d4 <_CORE_barrier_Wait+0x48>            <== NOT EXECUTED
    if ( the_barrier->number_of_waiting_threads ==                    
a00122c8:	e5905044 	ldr	r5, [r0, #68]	; 0x44                          <== NOT EXECUTED
a00122cc:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a00122d0:	0a000008 	beq	a00122f8 <_CORE_barrier_Wait+0x6c>            <== NOT EXECUTED
a00122d4:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a00122d8:	e5802030 	str	r2, [r0, #48]	; 0x30                          <== NOT EXECUTED
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );   
  executing->Wait.queue          = &the_barrier->Wait_queue;          
a00122dc:	e58c0044 	str	r0, [ip, #68]	; 0x44                          <== NOT EXECUTED
  executing->Wait.id             = id;                                
a00122e0:	e58c1020 	str	r1, [ip, #32]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a00122e4:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
a00122e8:	e59f2020 	ldr	r2, [pc, #32]	; a0012310 <_CORE_barrier_Wait+0x84><== NOT EXECUTED
a00122ec:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
}                                                                     
a00122f0:	e8bd0070 	pop	{r4, r5, r6}                                  <== NOT EXECUTED
  _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );   
  executing->Wait.queue          = &the_barrier->Wait_queue;          
  executing->Wait.id             = id;                                
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
a00122f4:	eafff097 	b	a000e558 <_Thread_queue_Enqueue_with_handler>   <== NOT EXECUTED
  _ISR_Disable( level );                                              
  the_barrier->number_of_waiting_threads++;                           
  if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {     
    if ( the_barrier->number_of_waiting_threads ==                    
	 the_barrier->Attributes.maximum_count) {                            
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
a00122f8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a00122fc:	e58c3034 	str	r3, [ip, #52]	; 0x34                          <== NOT EXECUTED
a0012300:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
  executing->Wait.queue          = &the_barrier->Wait_queue;          
  executing->Wait.id             = id;                                
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );         
}                                                                     
a0012304:	e8bd0070 	pop	{r4, r5, r6}                                  <== NOT EXECUTED
  if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {     
    if ( the_barrier->number_of_waiting_threads ==                    
	 the_barrier->Attributes.maximum_count) {                            
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
      _ISR_Enable( level );                                           
      _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
a0012308:	eaffffd3 	b	a001225c <_CORE_barrier_Release>                <== NOT EXECUTED
                                                                      

a001afc8 <_CORE_message_queue_Broadcast>: { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) {
a001afc8:	e590304c 	ldr	r3, [r0, #76]	; 0x4c                          <== NOT EXECUTED
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif                                                              
  uint32_t                                  *count                    
)                                                                     
{                                                                     
a001afcc:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
a001afd0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif                                                              
  uint32_t                                  *count                    
)                                                                     
{                                                                     
a001afd4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a001afd8:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a001afdc:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
a001afe0:	e59da020 	ldr	sl, [sp, #32]                                 <== NOT EXECUTED
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
a001afe4:	3a000013 	bcc	a001b038 <_CORE_message_queue_Broadcast+0x70> <== NOT EXECUTED
   *  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 ) {         
a001afe8:	e5906048 	ldr	r6, [r0, #72]	; 0x48                          <== NOT EXECUTED
a001afec:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a001aff0:	0a000009 	beq	a001b01c <_CORE_message_queue_Broadcast+0x54> <== NOT EXECUTED
    *count = 0;                                                       
a001aff4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a001aff8:	e58a0000 	str	r0, [sl]                                      <== NOT EXECUTED
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                      
a001affc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
a001b000:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
a001b004:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a001b008:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a001b00c:	eb002024 	bl	a00230a4 <memcpy>                              <== NOT EXECUTED
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
a001b010:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
   */                                                                 
  number_broadcasted = 0;                                             
  while ((the_thread =                                                
          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {   
    waitp = &the_thread->Wait;                                        
    number_broadcasted += 1;                                          
a001b014:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
      buffer,                                                         
      waitp->return_argument_second.mutable_object,                   
      size                                                            
    );                                                                
                                                                      
    *(size_t *) the_thread->Wait.return_argument = size;              
a001b018:	e5835000 	str	r5, [r3]                                      <== NOT EXECUTED
  /*                                                                  
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.                                              
   */                                                                 
  number_broadcasted = 0;                                             
  while ((the_thread =                                                
a001b01c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a001b020:	eb000b15 	bl	a001dc7c <_Thread_queue_Dequeue>               <== NOT EXECUTED
a001b024:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a001b028:	1afffff4 	bne	a001b000 <_CORE_message_queue_Broadcast+0x38> <== NOT EXECUTED
      if ( !_Objects_Is_local_id( the_thread->Object.id ) )           
        (*api_message_queue_mp_support) ( the_thread, id );           
    #endif                                                            
                                                                      
  }                                                                   
  *count = number_broadcasted;                                        
a001b02c:	e58a6000 	str	r6, [sl]                                      <== NOT EXECUTED
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                        
a001b030:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001b034:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  Thread_Control          *the_thread;                                
  uint32_t                 number_broadcasted;                        
  Thread_Wait_information *waitp;                                     
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
    return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;                    
a001b038:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    #endif                                                            
                                                                      
  }                                                                   
  *count = number_broadcasted;                                        
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                        
}                                                                     
a001b03c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a001042c <_CORE_message_queue_Close>: void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) {
a001042c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a0010430:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  /*                                                                  
   *  This will flush blocked threads whether they were blocked on    
   *  a send or receive.                                              
   */                                                                 
                                                                      
  _Thread_queue_Flush(                                                
a0010434:	ebfff3d5 	bl	a000d390 <_Thread_queue_Flush>                 <== NOT EXECUTED
   *  This removes all messages from the pending message queue.  Since
   *  we just flushed all waiting threads, we don't have to worry about
   *  the flush satisfying any blocked senders as a side-effect.      
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages != 0 )           
a0010438:	e5943048 	ldr	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
a001043c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010440:	0a000001 	beq	a001044c <_CORE_message_queue_Close+0x20>     <== NOT EXECUTED
    (void) _CORE_message_queue_Flush_support( the_message_queue );    
a0010444:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010448:	eb000002 	bl	a0010458 <_CORE_message_queue_Flush_support>   <== NOT EXECUTED
                                                                      
  (void) _Workspace_Free( the_message_queue->message_buffers );       
a001044c:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
                                                                      
}                                                                     
a0010450:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( the_message_queue->number_of_pending_messages != 0 )           
    (void) _CORE_message_queue_Flush_support( the_message_queue );    
                                                                      
  (void) _Workspace_Free( the_message_queue->message_buffers );       
a0010454:	eafff668 	b	a000ddfc <_Workspace_Free>                      <== NOT EXECUTED
                                                                      

a001b06c <_CORE_message_queue_Flush>: uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 )
a001b06c:	e5903048 	ldr	r3, [r0, #72]	; 0x48                          <== NOT EXECUTED
a001b070:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a001b074:	1a000001 	bne	a001b080 <_CORE_message_queue_Flush+0x14>     <== NOT EXECUTED
    return _CORE_message_queue_Flush_support( the_message_queue );    
  else                                                                
    return 0;                                                         
}                                                                     
a001b078:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a001b07c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
uint32_t   _CORE_message_queue_Flush(                                 
  CORE_message_queue_Control *the_message_queue                       
)                                                                     
{                                                                     
  if ( the_message_queue->number_of_pending_messages != 0 )           
    return _CORE_message_queue_Flush_support( the_message_queue );    
a001b080:	eaffffff 	b	a001b084 <_CORE_message_queue_Flush_support>    <== NOT EXECUTED
                                                                      

a0010458 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) {
a0010458:	e92d00f0 	push	{r4, r5, r6, r7}                             <== NOT EXECUTED
a001045c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0010460:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a0010464:	e3852080 	orr	r2, r5, #128	; 0x80                           <== NOT EXECUTED
a0010468:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
    count = the_message_queue->number_of_pending_messages;            
    the_message_queue->number_of_pending_messages = 0;                
  _ISR_Enable( level );                                               
  return count;                                                       
}                                                                     
a001046c:	e5900050 	ldr	r0, [r0, #80]	; 0x50                          <== NOT EXECUTED
a0010470:	e593c058 	ldr	ip, [r3, #88]	; 0x58                          <== NOT EXECUTED
   *  fixed execution time that only deals with pending messages.     
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
    inactive_head = _Chain_Head( &the_message_queue->Inactive_messages );
    inactive_first = inactive_head->next;;                            
a0010474:	e5934060 	ldr	r4, [r3, #96]	; 0x60                          <== NOT EXECUTED
    message_queue_first = _Chain_First( &the_message_queue->Pending_messages );
    message_queue_last = _Chain_Last( &the_message_queue->Pending_messages );
                                                                      
    inactive_head->next = message_queue_first;                        
a0010478:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a001047c:	e5a20060 	str	r0, [r2, #96]!	; 0x60                         <== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
a0010480:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a0010484:	e2837054 	add	r7, r3, #84	; 0x54                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
a0010488:	e2836050 	add	r6, r3, #80	; 0x50                            <== NOT EXECUTED
    message_queue_last->next = inactive_first;                        
    inactive_first->previous = message_queue_last;                    
a001048c:	e584c004 	str	ip, [r4, #4]                                  <== NOT EXECUTED
    inactive_first = inactive_head->next;;                            
    message_queue_first = _Chain_First( &the_message_queue->Pending_messages );
    message_queue_last = _Chain_Last( &the_message_queue->Pending_messages );
                                                                      
    inactive_head->next = message_queue_first;                        
    message_queue_last->next = inactive_first;                        
a0010490:	e58c4000 	str	r4, [ip]                                      <== NOT EXECUTED
    inactive_first->previous = message_queue_last;                    
    message_queue_first->previous = inactive_head;                    
a0010494:	e5802004 	str	r2, [r0, #4]                                  <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a0010498:	e5837050 	str	r7, [r3, #80]	; 0x50                          <== NOT EXECUTED
                                                                      
    _Chain_Initialize_empty( &the_message_queue->Pending_messages );  
                                                                      
    count = the_message_queue->number_of_pending_messages;            
a001049c:	e5930048 	ldr	r0, [r3, #72]	; 0x48                          <== NOT EXECUTED
  head->previous = NULL;                                              
a00104a0:	e5831054 	str	r1, [r3, #84]	; 0x54                          <== NOT EXECUTED
  tail->previous = head;                                              
a00104a4:	e5836058 	str	r6, [r3, #88]	; 0x58                          <== NOT EXECUTED
    the_message_queue->number_of_pending_messages = 0;                
a00104a8:	e5831048 	str	r1, [r3, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a00104ac:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
  return count;                                                       
}                                                                     
a00104b0:	e8bd00f0 	pop	{r4, r5, r6, r7}                              <== NOT EXECUTED
a00104b4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0013224 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) {
a0013224:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  /*                                                                  
   *  Round size up to multiple of a pointer for chain init and       
   *  check for overflow on adding overhead to each message.          
   */                                                                 
  allocated_message_size = maximum_message_size;                      
  if (allocated_message_size & (sizeof(uint32_t) - 1)) {              
a0013228:	e3130003 	tst	r3, #3                                        <== NOT EXECUTED
  CORE_message_queue_Control    *the_message_queue,                   
  CORE_message_queue_Attributes *the_message_queue_attributes,        
  uint32_t                       maximum_pending_messages,            
  size_t                         maximum_message_size                 
)                                                                     
{                                                                     
a001322c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  size_t message_buffering_required;                                  
  size_t allocated_message_size;                                      
                                                                      
  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
  the_message_queue->number_of_pending_messages = 0;                  
a0013230:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  CORE_message_queue_Control    *the_message_queue,                   
  CORE_message_queue_Attributes *the_message_queue_attributes,        
  uint32_t                       maximum_pending_messages,            
  size_t                         maximum_message_size                 
)                                                                     
{                                                                     
a0013234:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0013238:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  size_t message_buffering_required;                                  
  size_t allocated_message_size;                                      
                                                                      
  the_message_queue->maximum_pending_messages   = maximum_pending_messages;
a001323c:	e5842044 	str	r2, [r4, #68]	; 0x44                          <== NOT EXECUTED
  the_message_queue->number_of_pending_messages = 0;                  
a0013240:	e5840048 	str	r0, [r4, #72]	; 0x48                          <== NOT EXECUTED
  the_message_queue->maximum_message_size       = maximum_message_size;
a0013244:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
  /*                                                                  
   *  Round size up to multiple of a pointer for chain init and       
   *  check for overflow on adding overhead to each message.          
   */                                                                 
  allocated_message_size = maximum_message_size;                      
  if (allocated_message_size & (sizeof(uint32_t) - 1)) {              
a0013248:	01a01003 	moveq	r1, r3                                      <== NOT EXECUTED
a001324c:	0a000005 	beq	a0013268 <_CORE_message_queue_Initialize+0x44><== NOT EXECUTED
    allocated_message_size += sizeof(uint32_t);                       
a0013250:	e2831004 	add	r1, r3, #4                                    <== NOT EXECUTED
    allocated_message_size &= ~(sizeof(uint32_t) - 1);                
a0013254:	e3c11003 	bic	r1, r1, #3                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (allocated_message_size < maximum_message_size)                  
a0013258:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a001325c:	9a000001 	bls	a0013268 <_CORE_message_queue_Initialize+0x44><== NOT EXECUTED
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
}                                                                     
a0013260:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0013264:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   *  Calculate how much total memory is required for message buffering and
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
a0013268:	e2816010 	add	r6, r1, #16                                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Calculate how much total memory is required for message buffering and
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
a001326c:	e0000692 	mul	r0, r2, r6                                    <== NOT EXECUTED
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
a0013270:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
    return false;                                                     
a0013274:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
   *  check for overflow on the multiplication.                       
   */                                                                 
  message_buffering_required = (size_t) maximum_pending_messages *    
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
                                                                      
  if (message_buffering_required < allocated_message_size)            
a0013278:	3afffff8 	bcc	a0013260 <_CORE_message_queue_Initialize+0x3c><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
     _Workspace_Allocate( message_buffering_required );               
a001327c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0013280:	eb000bd4 	bl	a00161d8 <_Workspace_Allocate>                 <== NOT EXECUTED
                                                                      
  if (the_message_queue->message_buffers == 0)                        
a0013284:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
     _Workspace_Allocate( message_buffering_required );               
a0013288:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
    return false;                                                     
                                                                      
  /*                                                                  
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
a001328c:	e584005c 	str	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
a0013290:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
    return false;                                                     
a0013294:	01a00000 	moveq	r0, r0                                      <== NOT EXECUTED
   *  Attempt to allocate the message memory                          
   */                                                                 
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)  
     _Workspace_Allocate( message_buffering_required );               
                                                                      
  if (the_message_queue->message_buffers == 0)                        
a0013298:	0afffff0 	beq	a0013260 <_CORE_message_queue_Initialize+0x3c><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the pool of inactive messages, pending messages,     
   *  and set of waiting threads.                                     
   */                                                                 
  _Chain_Initialize (                                                 
a001329c:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
a00132a0:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a00132a4:	eb0013b0 	bl	a001816c <_Chain_Initialize>                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a00132a8:	e2842054 	add	r2, r4, #84	; 0x54                            <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
a00132ac:	e5842050 	str	r2, [r4, #80]	; 0x50                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
a00132b0:	e2843050 	add	r3, r4, #80	; 0x50                            <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
a00132b4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00132b8:	e5842054 	str	r2, [r4, #84]	; 0x54                          <== NOT EXECUTED
  tail->previous = head;                                              
a00132bc:	e5843058 	str	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );                                                                  
                                                                      
  _Chain_Initialize_empty( &the_message_queue->Pending_messages );    
                                                                      
  _Thread_queue_Initialize(                                           
a00132c0:	e5951000 	ldr	r1, [r5]                                      <== NOT EXECUTED
a00132c4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00132c8:	e3a02080 	mov	r2, #128	; 0x80                               <== NOT EXECUTED
a00132cc:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
a00132d0:	13a01000 	movne	r1, #0                                      <== NOT EXECUTED
a00132d4:	03a01001 	moveq	r1, #1                                      <== NOT EXECUTED
a00132d8:	e3a03006 	mov	r3, #6                                        <== NOT EXECUTED
a00132dc:	eb000932 	bl	a00157ac <_Thread_queue_Initialize>            <== NOT EXECUTED
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,                                       
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT                                 
  );                                                                  
                                                                      
  return true;                                                        
a00132e0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a00132e4:	eaffffdd 	b	a0013260 <_CORE_message_queue_Initialize+0x3c>  <== NOT EXECUTED
                                                                      

a00181d0 <_CORE_message_queue_Insert_message>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile (
a00181d0:	e10fc000 	mrs	ip, CPSR                                      <== NOT EXECUTED
a00181d4:	e38c3080 	orr	r3, ip, #128	; 0x80                           <== NOT EXECUTED
a00181d8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  _CORE_message_queue_Set_message_priority( the_message, submit_type );
                                                                      
  #if !defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)           
    _ISR_Disable( level );                                            
      SET_NOTIFY();                                                   
      the_message_queue->number_of_pending_messages++;                
a00181dc:	e5903048 	ldr	r3, [r0, #72]	; 0x48                          <== NOT EXECUTED
      if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST )           
a00181e0:	e3720106 	cmn	r2, #-2147483647	; 0x80000001                 <== NOT EXECUTED
  _CORE_message_queue_Set_message_priority( the_message, submit_type );
                                                                      
  #if !defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)           
    _ISR_Disable( level );                                            
      SET_NOTIFY();                                                   
      the_message_queue->number_of_pending_messages++;                
a00181e4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a00181e8:	e5803048 	str	r3, [r0, #72]	; 0x48                          <== NOT EXECUTED
      if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST )           
a00181ec:	0a000007 	beq	a0018210 <_CORE_message_queue_Insert_message+0x40><== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a00181f0:	e5903050 	ldr	r3, [r0, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(                 
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);        
a00181f4:	e2802050 	add	r2, r0, #80	; 0x50                            <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a00181f8:	e5812004 	str	r2, [r1, #4]                                  <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a00181fc:	e5801050 	str	r1, [r0, #80]	; 0x50                          <== NOT EXECUTED
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a0018200:	e5831004 	str	r1, [r3, #4]                                  <== NOT EXECUTED
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a0018204:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0018208:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
     *  the message is actually in the queue at this point.           
     */                                                               
    if ( notify && the_message_queue->notify_handler )                
      (*the_message_queue->notify_handler)(the_message_queue->notify_argument);
  #endif                                                              
}                                                                     
a001820c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a0018210:	e5903058 	ldr	r3, [r0, #88]	; 0x58                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a0018214:	e2802054 	add	r2, r0, #84	; 0x54                            <== NOT EXECUTED
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a0018218:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
  tail->previous = the_node;                                          
a001821c:	e5801058 	str	r1, [r0, #88]	; 0x58                          <== NOT EXECUTED
  old_last->next = the_node;                                          
a0018220:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
  the_node->previous = old_last;                                      
a0018224:	e5813004 	str	r3, [r1, #4]                                  <== NOT EXECUTED
a0018228:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a001822c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00132e8 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) {
a00132e8:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
a00132ec:	e59f50cc 	ldr	r5, [pc, #204]	; a00133c0 <_CORE_message_queue_Seize+0xd8><== NOT EXECUTED
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
a00132f0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
a00132f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
{                                                                     
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
a00132f8:	e595c004 	ldr	ip, [r5, #4]                                  <== NOT EXECUTED
  void                            *buffer,                            
  size_t                          *size_p,                            
  bool                             wait,                              
  Watchdog_Interval                timeout                            
)                                                                     
{                                                                     
a00132fc:	e59d8020 	ldr	r8, [sp, #32]                                 <== NOT EXECUTED
a0013300:	e5dd601c 	ldrb	r6, [sp, #28]                                <== NOT EXECUTED
  ISR_Level                          level;                           
  CORE_message_queue_Buffer_control *the_message;                     
  Thread_Control                    *executing;                       
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
a0013304:	e58c0034 	str	r0, [ip, #52]	; 0x34                          <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0013308:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a001330c:	e3807080 	orr	r7, r0, #128	; 0x80                           <== NOT EXECUTED
a0013310:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
a0013314:	e5947050 	ldr	r7, [r4, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a0013318:	e284a054 	add	sl, r4, #84	; 0x54                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
a001331c:	e157000a 	cmp	r7, sl                                        <== NOT EXECUTED
a0013320:	0a000014 	beq	a0013378 <_CORE_message_queue_Seize+0x90>     <== NOT EXECUTED
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
a0013324:	e597c000 	ldr	ip, [r7]                                      <== NOT EXECUTED
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 
  _ISR_Disable( level );                                              
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
    the_message_queue->number_of_pending_messages -= 1;               
a0013328:	e594e048 	ldr	lr, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
  head->next = new_first;                                             
a001332c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0013330:	e5a1c050 	str	ip, [r1, #80]!	; 0x50                         <== NOT EXECUTED
a0013334:	e24ee001 	sub	lr, lr, #1                                    <== NOT EXECUTED
  new_first->previous = head;                                         
a0013338:	e58c1004 	str	r1, [ip, #4]                                  <== NOT EXECUTED
a001333c:	e584e048 	str	lr, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0013340:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
                                                                      
    *size_p = the_message->Contents.size;                             
a0013344:	e5970008 	ldr	r0, [r7, #8]                                  <== NOT EXECUTED
    _Thread_Executing->Wait.count =                                   
a0013348:	e5951004 	ldr	r1, [r5, #4]                                  <== NOT EXECUTED
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {                                        
    the_message_queue->number_of_pending_messages -= 1;               
    _ISR_Enable( level );                                             
                                                                      
    *size_p = the_message->Contents.size;                             
a001334c:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
    _Thread_Executing->Wait.count =                                   
a0013350:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0013354:	e5810024 	str	r0, [r1, #36]	; 0x24                          <== NOT EXECUTED
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
a0013358:	e287100c 	add	r1, r7, #12                                   <== NOT EXECUTED
a001335c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0013360:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a0013364:	eb001dc8 	bl	a001aa8c <memcpy>                              <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (   
  CORE_message_queue_Control        *the_message_queue,               
  CORE_message_queue_Buffer_control *the_message                      
)                                                                     
{                                                                     
  _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
a0013368:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
a001336c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
a0013370:	e8bd45f0 	pop	{r4, r5, r6, r7, r8, sl, lr}                  <== NOT EXECUTED
a0013374:	eaffff80 	b	a001317c <_Chain_Append>                        <== NOT EXECUTED
      return;                                                         
    }                                                                 
    #endif                                                            
  }                                                                   
                                                                      
  if ( !wait ) {                                                      
a0013378:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a001337c:	1a000003 	bne	a0013390 <_CORE_message_queue_Seize+0xa8>     <== NOT EXECUTED
a0013380:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
a0013384:	e3a03004 	mov	r3, #4                                        <== NOT EXECUTED
a0013388:	e58c3034 	str	r3, [ip, #52]	; 0x34                          <== NOT EXECUTED
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
}                                                                     
a001338c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0013390:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
a0013394:	e5845030 	str	r5, [r4, #48]	; 0x30                          <== NOT EXECUTED
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
    return;                                                           
  }                                                                   
                                                                      
  _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
  executing->Wait.queue = &the_message_queue->Wait_queue;             
a0013398:	e58c4044 	str	r4, [ip, #68]	; 0x44                          <== NOT EXECUTED
  executing->Wait.id = id;                                            
a001339c:	e58c1020 	str	r1, [ip, #32]                                 <== NOT EXECUTED
  executing->Wait.return_argument_second.mutable_object = buffer;     
a00133a0:	e58c202c 	str	r2, [ip, #44]	; 0x2c                          <== NOT EXECUTED
  executing->Wait.return_argument = size_p;                           
a00133a4:	e58c3028 	str	r3, [ip, #40]	; 0x28                          <== NOT EXECUTED
a00133a8:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
a00133ac:	e59f2010 	ldr	r2, [pc, #16]	; a00133c4 <_CORE_message_queue_Seize+0xdc><== NOT EXECUTED
a00133b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00133b4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
}                                                                     
a00133b8:	e8bd45f0 	pop	{r4, r5, r6, r7, r8, sl, lr}                  <== NOT EXECUTED
  executing->Wait.return_argument_second.mutable_object = buffer;     
  executing->Wait.return_argument = size_p;                           
  /* Wait.count will be filled in with the message priority */        
  _ISR_Enable( level );                                               
                                                                      
  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );   
a00133bc:	ea00084c 	b	a00154f4 <_Thread_queue_Enqueue_with_handler>   <== NOT EXECUTED
                                                                      

a00133c8 <_CORE_message_queue_Submit>: ) { CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) {
a00133c8:	e590304c 	ldr	r3, [r0, #76]	; 0x4c                          <== NOT EXECUTED
  #endif                                                              
  CORE_message_queue_Submit_types            submit_type,             
  bool                                       wait,                    
  Watchdog_Interval                          timeout                  
)                                                                     
{                                                                     
a00133cc:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  CORE_message_queue_Buffer_control   *the_message;                   
  Thread_Control                      *the_thread;                    
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
a00133d0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
  #endif                                                              
  CORE_message_queue_Submit_types            submit_type,             
  bool                                       wait,                    
  Watchdog_Interval                          timeout                  
)                                                                     
{                                                                     
a00133d4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00133d8:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a00133dc:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
a00133e0:	e59d7020 	ldr	r7, [sp, #32]                                 <== NOT EXECUTED
  CORE_message_queue_Buffer_control   *the_message;                   
  Thread_Control                      *the_thread;                    
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
a00133e4:	3a000015 	bcc	a0013440 <_CORE_message_queue_Submit+0x78>    <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Is there a thread currently waiting on this message queue?      
   */                                                                 
  if ( the_message_queue->number_of_pending_messages == 0 ) {         
a00133e8:	e5906048 	ldr	r6, [r0, #72]	; 0x48                          <== NOT EXECUTED
a00133ec:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a00133f0:	0a000014 	beq	a0013448 <_CORE_message_queue_Submit+0x80>    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  No one waiting on the message queue at this time, so attempt to 
   *  queue the message up for a future receive.                      
   */                                                                 
  if ( the_message_queue->number_of_pending_messages <                
a00133f4:	e5943044 	ldr	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
a00133f8:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a00133fc:	8a000001 	bhi	a0013408 <_CORE_message_queue_Submit+0x40>    <== NOT EXECUTED
    );                                                                
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                      
  }                                                                   
                                                                      
  #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)              
    return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;                        
a0013400:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
      _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
    }                                                                 
                                                                      
    return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;                
  #endif                                                              
}                                                                     
a0013404:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
_CORE_message_queue_Allocate_message_buffer (                         
    CORE_message_queue_Control *the_message_queue                     
)                                                                     
{                                                                     
   return (CORE_message_queue_Buffer_control *)                       
     _Chain_Get( &the_message_queue->Inactive_messages );             
a0013408:	e2840060 	add	r0, r4, #96	; 0x60                            <== NOT EXECUTED
a001340c:	ebffff6d 	bl	a00131c8 <_Chain_Get>                          <== NOT EXECUTED
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
a0013410:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
_CORE_message_queue_Allocate_message_buffer (                         
    CORE_message_queue_Control *the_message_queue                     
)                                                                     
{                                                                     
   return (CORE_message_queue_Buffer_control *)                       
     _Chain_Get( &the_message_queue->Inactive_messages );             
a0013414:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  const void *source,                                                 
  void       *destination,                                            
  size_t      size                                                    
)                                                                     
{                                                                     
  memcpy(destination, source, size);                                  
a0013418:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a001341c:	e280000c 	add	r0, r0, #12                                   <== NOT EXECUTED
a0013420:	eb001d99 	bl	a001aa8c <memcpy>                              <== NOT EXECUTED
      size                                                            
    );                                                                
    the_message->Contents.size = size;                                
    _CORE_message_queue_Set_message_priority( the_message, submit_type );
                                                                      
    _CORE_message_queue_Insert_message(                               
a0013424:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    _CORE_message_queue_Copy_buffer(                                  
      buffer,                                                         
      the_message->Contents.buffer,                                   
      size                                                            
    );                                                                
    the_message->Contents.size = size;                                
a0013428:	e5865008 	str	r5, [r6, #8]                                  <== NOT EXECUTED
    _CORE_message_queue_Set_message_priority( the_message, submit_type );
                                                                      
    _CORE_message_queue_Insert_message(                               
a001342c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0013430:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0013434:	eb001365 	bl	a00181d0 <_CORE_message_queue_Insert_message>  <== NOT EXECUTED
       the_message_queue,                                             
       the_message,                                                   
       submit_type                                                    
    );                                                                
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                      
a0013438:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a001343c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
{                                                                     
  CORE_message_queue_Buffer_control   *the_message;                   
  Thread_Control                      *the_thread;                    
                                                                      
  if ( size > the_message_queue->maximum_message_size ) {             
    return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;                    
a0013440:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0013444:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Is there a thread currently waiting on this message queue?      
   */                                                                 
  if ( the_message_queue->number_of_pending_messages == 0 ) {         
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
a0013448:	eb0007cb 	bl	a001537c <_Thread_queue_Dequeue>               <== NOT EXECUTED
    if ( the_thread ) {                                               
a001344c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
a0013450:	05946048 	ldreq	r6, [r4, #72]	; 0x48                        <== NOT EXECUTED
a0013454:	0affffe6 	beq	a00133f4 <_CORE_message_queue_Submit+0x2c>    <== NOT EXECUTED
a0013458:	e598002c 	ldr	r0, [r8, #44]	; 0x2c                          <== NOT EXECUTED
a001345c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a0013460:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0013464:	eb001d88 	bl	a001aa8c <memcpy>                              <== NOT EXECUTED
      _CORE_message_queue_Copy_buffer(                                
        buffer,                                                       
        the_thread->Wait.return_argument_second.mutable_object,       
        size                                                          
      );                                                              
      *(size_t *) the_thread->Wait.return_argument = size;            
a0013468:	e5983028 	ldr	r3, [r8, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
      #if defined(RTEMS_MULTIPROCESSING)                              
        if ( !_Objects_Is_local_id( the_thread->Object.id ) )         
          (*api_message_queue_mp_support) ( the_thread, id );         
      #endif                                                          
      return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                    
a001346c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
      _CORE_message_queue_Copy_buffer(                                
        buffer,                                                       
        the_thread->Wait.return_argument_second.mutable_object,       
        size                                                          
      );                                                              
      *(size_t *) the_thread->Wait.return_argument = size;            
a0013470:	e5835000 	str	r5, [r3]                                      <== NOT EXECUTED
      the_thread->Wait.count = (uint32_t) submit_type;                
a0013474:	e5887024 	str	r7, [r8, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      #if defined(RTEMS_MULTIPROCESSING)                              
        if ( !_Objects_Is_local_id( the_thread->Object.id ) )         
          (*api_message_queue_mp_support) ( the_thread, id );         
      #endif                                                          
      return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;                    
a0013478:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a000a470 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) {
a000a470:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
                initial_lock == CORE_MUTEX_UNLOCKED );                
 */                                                                   
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
a000a474:	e3a05000 	mov	r5, #0                                        
CORE_mutex_Status _CORE_mutex_Initialize(                             
  CORE_mutex_Control           *the_mutex,                            
  CORE_mutex_Attributes        *the_mutex_attributes,                 
  uint32_t                      initial_lock                          
)                                                                     
{                                                                     
a000a478:	e1a0c000 	mov	ip, r0                                        
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
a000a47c:	e1520005 	cmp	r2, r5                                        
CORE_mutex_Status _CORE_mutex_Initialize(                             
  CORE_mutex_Control           *the_mutex,                            
  CORE_mutex_Attributes        *the_mutex_attributes,                 
  uint32_t                      initial_lock                          
)                                                                     
{                                                                     
a000a480:	e1a06002 	mov	r6, r2                                        
/* Add this to the RTEMS environment later ?????????                  
  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||                  
                initial_lock == CORE_MUTEX_UNLOCKED );                
 */                                                                   
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
a000a484:	e2807040 	add	r7, r0, #64	; 0x40                            
CORE_mutex_Status _CORE_mutex_Initialize(                             
  CORE_mutex_Control           *the_mutex,                            
  CORE_mutex_Attributes        *the_mutex_attributes,                 
  uint32_t                      initial_lock                          
)                                                                     
{                                                                     
a000a488:	e1a04001 	mov	r4, r1                                        
/* Add this to the RTEMS environment later ?????????                  
  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||                  
                initial_lock == CORE_MUTEX_UNLOCKED );                
 */                                                                   
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
a000a48c:	e891000f 	ldm	r1, {r0, r1, r2, r3}                          
  the_mutex->lock          = initial_lock;                            
a000a490:	e58c6050 	str	r6, [ip, #80]	; 0x50                          
/* Add this to the RTEMS environment later ?????????                  
  rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||                  
                initial_lock == CORE_MUTEX_UNLOCKED );                
 */                                                                   
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
a000a494:	e887000f 	stm	r7, {r0, r1, r2, r3}                          
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
a000a498:	e58c5058 	str	r5, [ip, #88]	; 0x58                          
#endif                                                                
                                                                      
      _Thread_Executing->resource_count++;                            
    }                                                                 
  } else {                                                            
    the_mutex->nest_count = 0;                                        
a000a49c:	158c5054 	strne	r5, [ip, #84]	; 0x54                        
    the_mutex->holder     = NULL;                                     
a000a4a0:	158c505c 	strne	r5, [ip, #92]	; 0x5c                        
    the_mutex->holder_id  = 0;                                        
a000a4a4:	158c5060 	strne	r5, [ip, #96]	; 0x60                        
                                                                      
  the_mutex->Attributes    = *the_mutex_attributes;                   
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
a000a4a8:	1a00000b 	bne	a000a4dc <_CORE_mutex_Initialize+0x6c>        
    the_mutex->nest_count = 1;                                        
    the_mutex->holder     = _Thread_Executing;                        
a000a4ac:	e59f3074 	ldr	r3, [pc, #116]	; a000a528 <_CORE_mutex_Initialize+0xb8><== NOT EXECUTED
  the_mutex->Attributes    = *the_mutex_attributes;                   
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
    the_mutex->nest_count = 1;                                        
a000a4b0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,                                         
    CORE_MUTEX_TIMEOUT                                                
  );                                                                  
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
a000a4b4:	e59c2048 	ldr	r2, [ip, #72]	; 0x48                          <== NOT EXECUTED
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
    the_mutex->nest_count = 1;                                        
    the_mutex->holder     = _Thread_Executing;                        
a000a4b8:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  the_mutex->Attributes    = *the_mutex_attributes;                   
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
    the_mutex->nest_count = 1;                                        
a000a4bc:	e58c1054 	str	r1, [ip, #84]	; 0x54                          <== NOT EXECUTED
    the_mutex->holder     = _Thread_Executing;                        
    the_mutex->holder_id  = _Thread_Executing->Object.id;             
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
a000a4c0:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
    the_mutex->nest_count = 1;                                        
    the_mutex->holder     = _Thread_Executing;                        
    the_mutex->holder_id  = _Thread_Executing->Object.id;             
a000a4c4:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
  the_mutex->lock          = initial_lock;                            
  the_mutex->blocked_count = 0;                                       
                                                                      
  if ( initial_lock == CORE_MUTEX_LOCKED ) {                          
    the_mutex->nest_count = 1;                                        
    the_mutex->holder     = _Thread_Executing;                        
a000a4c8:	e58c305c 	str	r3, [ip, #92]	; 0x5c                          <== NOT EXECUTED
    the_mutex->holder_id  = _Thread_Executing->Object.id;             
a000a4cc:	e58c1060 	str	r1, [ip, #96]	; 0x60                          <== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
a000a4d0:	0a00000a 	beq	a000a500 <_CORE_mutex_Initialize+0x90>        <== NOT EXECUTED
a000a4d4:	e3520003 	cmp	r2, #3                                        <== NOT EXECUTED
a000a4d8:	0a000008 	beq	a000a500 <_CORE_mutex_Initialize+0x90>        <== NOT EXECUTED
    the_mutex->nest_count = 0;                                        
    the_mutex->holder     = NULL;                                     
    the_mutex->holder_id  = 0;                                        
  }                                                                   
                                                                      
  _Thread_queue_Initialize(                                           
a000a4dc:	e5941008 	ldr	r1, [r4, #8]                                  
a000a4e0:	e1a0000c 	mov	r0, ip                                        
a000a4e4:	e3a02b01 	mov	r2, #1024	; 0x400                             
a000a4e8:	e2511000 	subs	r1, r1, #0                                   
a000a4ec:	13a01001 	movne	r1, #1                                      
a000a4f0:	e3a03004 	mov	r3, #4                                        
a000a4f4:	eb000880 	bl	a000c6fc <_Thread_queue_Initialize>            
      THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
    STATES_WAITING_FOR_MUTEX,                                         
    CORE_MUTEX_TIMEOUT                                                
  );                                                                  
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a4f8:	e3a00000 	mov	r0, #0                                        
a000a4fc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
    the_mutex->holder     = _Thread_Executing;                        
    the_mutex->holder_id  = _Thread_Executing->Object.id;             
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
                                                                      
      if ( _Thread_Executing->current_priority <                      
a000a500:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
a000a504:	e59c204c 	ldr	r2, [ip, #76]	; 0x4c                          <== NOT EXECUTED
a000a508:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000a50c:	3a000003 	bcc	a000a520 <_CORE_mutex_Initialize+0xb0>        <== NOT EXECUTED
       _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,    
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif                                                                
                                                                      
      _Thread_Executing->resource_count++;                            
a000a510:	e593201c 	ldr	r2, [r3, #28]                                 <== NOT EXECUTED
a000a514:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a518:	e583201c 	str	r2, [r3, #28]                                 <== NOT EXECUTED
a000a51c:	eaffffee 	b	a000a4dc <_CORE_mutex_Initialize+0x6c>          <== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
                                                                      
      if ( _Thread_Executing->current_priority <                      
             the_mutex->Attributes.priority_ceiling )                 
       return CORE_MUTEX_STATUS_CEILING_VIOLATED;                     
a000a520:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,                                         
    CORE_MUTEX_TIMEOUT                                                
  );                                                                  
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
a000a524:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000a598 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) {
a000a598:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
a000a59c:	e59f40b4 	ldr	r4, [pc, #180]	; a000a658 <_CORE_mutex_Seize+0xc0>
  Objects_Id           _id,                                           
  bool                 _wait,                                         
  Watchdog_Interval    _timeout,                                      
  ISR_Level            _level                                         
)                                                                     
{                                                                     
a000a5a0:	e1a05000 	mov	r5, r0                                        
a000a5a4:	e1a06001 	mov	r6, r1                                        
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
a000a5a8:	e5940000 	ldr	r0, [r4]                                      
  Objects_Id           _id,                                           
  bool                 _wait,                                         
  Watchdog_Interval    _timeout,                                      
  ISR_Level            _level                                         
)                                                                     
{                                                                     
a000a5ac:	e1a08003 	mov	r8, r3                                        
a000a5b0:	e20270ff 	and	r7, r2, #255	; 0xff                           
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
a000a5b4:	e3500000 	cmp	r0, #0                                        
a000a5b8:	0a000001 	beq	a000a5c4 <_CORE_mutex_Seize+0x2c>             
a000a5bc:	e3570000 	cmp	r7, #0                                        
a000a5c0:	1a00001c 	bne	a000a638 <_CORE_mutex_Seize+0xa0>             
a000a5c4:	e1a00005 	mov	r0, r5                                        
a000a5c8:	e28d1018 	add	r1, sp, #24                                   
a000a5cc:	eb0012d0 	bl	a000f114 <_CORE_mutex_Seize_interrupt_trylock> 
a000a5d0:	e3500000 	cmp	r0, #0                                        
a000a5d4:	0a000016 	beq	a000a634 <_CORE_mutex_Seize+0x9c>             
a000a5d8:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a000a5dc:	1a000006 	bne	a000a5fc <_CORE_mutex_Seize+0x64>             <== NOT EXECUTED
a000a5e0:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
a000a5e4:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
a000a5e8:	e59f306c 	ldr	r3, [pc, #108]	; a000a65c <_CORE_mutex_Seize+0xc4><== NOT EXECUTED
a000a5ec:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000a5f0:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000a5f4:	e5832034 	str	r2, [r3, #52]	; 0x34                          <== NOT EXECUTED
a000a5f8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
a000a5fc:	e59f3058 	ldr	r3, [pc, #88]	; a000a65c <_CORE_mutex_Seize+0xc4><== NOT EXECUTED
a000a600:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a000a604:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000a608:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000a60c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a610:	e5851030 	str	r1, [r5, #48]	; 0x30                          <== NOT EXECUTED
a000a614:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
a000a618:	e5835044 	str	r5, [r3, #68]	; 0x44                          <== NOT EXECUTED
a000a61c:	e5836020 	str	r6, [r3, #32]                                 <== NOT EXECUTED
a000a620:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
a000a624:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
a000a628:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a62c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000a630:	ebffffbd 	bl	a000a52c <_CORE_mutex_Seize_interrupt_blocking><== NOT EXECUTED
a000a634:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
a000a638:	e59f3020 	ldr	r3, [pc, #32]	; a000a660 <_CORE_mutex_Seize+0xc8>
a000a63c:	e5933000 	ldr	r3, [r3]                                      
a000a640:	e3530001 	cmp	r3, #1                                        
a000a644:	9affffde 	bls	a000a5c4 <_CORE_mutex_Seize+0x2c>             
a000a648:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a64c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a650:	e3a02012 	mov	r2, #18                                       <== NOT EXECUTED
a000a654:	eb0001bf 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a000a52c <_CORE_mutex_Seize_interrupt_blocking>: ) { Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {
a000a52c:	e5903048 	ldr	r3, [r0, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
void _CORE_mutex_Seize_interrupt_blocking(                            
  CORE_mutex_Control  *the_mutex,                                     
  Watchdog_Interval    timeout                                        
)                                                                     
{                                                                     
a000a530:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  Thread_Control   *executing;                                        
                                                                      
  executing = _Thread_Executing;                                      
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {  
a000a534:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
  Watchdog_Interval    timeout                                        
)                                                                     
{                                                                     
  Thread_Control   *executing;                                        
                                                                      
  executing = _Thread_Executing;                                      
a000a538:	e59f3050 	ldr	r3, [pc, #80]	; a000a590 <_CORE_mutex_Seize_interrupt_blocking+0x64><== NOT EXECUTED
                                                                      
void _CORE_mutex_Seize_interrupt_blocking(                            
  CORE_mutex_Control  *the_mutex,                                     
  Watchdog_Interval    timeout                                        
)                                                                     
{                                                                     
a000a53c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000a540:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  Thread_Control   *executing;                                        
                                                                      
  executing = _Thread_Executing;                                      
a000a544:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {  
a000a548:	0a000008 	beq	a000a570 <_CORE_mutex_Seize_interrupt_blocking+0x44><== NOT EXECUTED
        false                                                         
      );                                                              
    }                                                                 
  }                                                                   
                                                                      
  the_mutex->blocked_count++;                                         
a000a54c:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );           
a000a550:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a554:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
        false                                                         
      );                                                              
    }                                                                 
  }                                                                   
                                                                      
  the_mutex->blocked_count++;                                         
a000a558:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000a55c:	e5843058 	str	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );           
a000a560:	e59f202c 	ldr	r2, [pc, #44]	; a000a594 <_CORE_mutex_Seize_interrupt_blocking+0x68><== NOT EXECUTED
a000a564:	eb0007b6 	bl	a000c444 <_Thread_queue_Enqueue_with_handler>  <== NOT EXECUTED
                                                                      
  _Thread_Enable_dispatch();                                          
}                                                                     
a000a568:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  the_mutex->blocked_count++;                                         
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );           
                                                                      
  _Thread_Enable_dispatch();                                          
a000a56c:	ea000697 	b	a000bfd0 <_Thread_Enable_dispatch>              <== NOT EXECUTED
{                                                                     
  Thread_Control   *executing;                                        
                                                                      
  executing = _Thread_Executing;                                      
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {  
    if ( the_mutex->holder->current_priority > executing->current_priority ) {
a000a570:	e590005c 	ldr	r0, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a000a574:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
a000a578:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a000a57c:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a000a580:	9afffff1 	bls	a000a54c <_CORE_mutex_Seize_interrupt_blocking+0x20><== NOT EXECUTED
      _Thread_Change_priority(                                        
a000a584:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000a588:	eb000570 	bl	a000bb50 <_Thread_Change_priority>             <== NOT EXECUTED
a000a58c:	eaffffee 	b	a000a54c <_CORE_mutex_Seize_interrupt_blocking+0x20><== NOT EXECUTED
                                                                      

a000f114 <_CORE_mutex_Seize_interrupt_trylock>: { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing;
a000f114:	e59f2140 	ldr	r2, [pc, #320]	; a000f25c <_CORE_mutex_Seize_interrupt_trylock+0x148>
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
a000f118:	e590c050 	ldr	ip, [r0, #80]	; 0x50                          
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)                 
int _CORE_mutex_Seize_interrupt_trylock(                              
  CORE_mutex_Control  *the_mutex,                                     
  ISR_Level           *level_p                                        
)                                                                     
{                                                                     
a000f11c:	e1a03000 	mov	r3, r0                                        
{                                                                     
  Thread_Control   *executing;                                        
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
a000f120:	e5922004 	ldr	r2, [r2, #4]                                  
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
a000f124:	e3a00000 	mov	r0, #0                                        
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
a000f128:	e15c0000 	cmp	ip, r0                                        
a000f12c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  Thread_Control   *executing;                                        
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
a000f130:	e5820034 	str	r0, [r2, #52]	; 0x34                          
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
a000f134:	0a00000e 	beq	a000f174 <_CORE_mutex_Seize_interrupt_trylock+0x60>
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}                                                                     
a000f138:	e593c048 	ldr	ip, [r3, #72]	; 0x48                          
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
    the_mutex->holder     = executing;                                
    the_mutex->holder_id  = executing->Object.id;                     
a000f13c:	e5925008 	ldr	r5, [r2, #8]                                  
    the_mutex->nest_count = 1;                                        
a000f140:	e3a04001 	mov	r4, #1                                        
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
a000f144:	e35c0002 	cmp	ip, #2                                        
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;         
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {                        
    the_mutex->lock       = CORE_MUTEX_LOCKED;                        
a000f148:	e5830050 	str	r0, [r3, #80]	; 0x50                          
    the_mutex->holder     = executing;                                
a000f14c:	e583205c 	str	r2, [r3, #92]	; 0x5c                          
    the_mutex->holder_id  = executing->Object.id;                     
a000f150:	e5835060 	str	r5, [r3, #96]	; 0x60                          
    the_mutex->nest_count = 1;                                        
a000f154:	e5834054 	str	r4, [r3, #84]	; 0x54                          
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 
a000f158:	0a00000a 	beq	a000f188 <_CORE_mutex_Seize_interrupt_trylock+0x74>
a000f15c:	e35c0003 	cmp	ip, #3                                        <== NOT EXECUTED
a000f160:	0a000014 	beq	a000f1b8 <_CORE_mutex_Seize_interrupt_trylock+0xa4><== NOT EXECUTED
a000f164:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000f168:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      executing->resource_count++;                                    
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
      _ISR_Enable( *level_p );                                        
      return 0;                                                       
a000f16c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f170:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  /*                                                                  
   *  At this point, we know the mutex was not available.  If this thread
   *  is the thread that has locked the mutex, let's see if we are allowed
   *  to nest access.                                                 
   */                                                                 
  if ( _Thread_Is_executing( the_mutex->holder ) ) {                  
a000f174:	e593005c 	ldr	r0, [r3, #92]	; 0x5c                          <== NOT EXECUTED
a000f178:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
a000f17c:	0a000008 	beq	a000f1a4 <_CORE_mutex_Seize_interrupt_trylock+0x90><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  The mutex is not available and the caller must deal with the possibility
   *  of blocking.                                                    
   */                                                                 
  return 1;                                                           
a000f180:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000f184:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
a000f188:	e592301c 	ldr	r3, [r2, #28]                                 
a000f18c:	e2833001 	add	r3, r3, #1                                    
a000f190:	e582301c 	str	r3, [r2, #28]                                 
a000f194:	e5913000 	ldr	r3, [r1]                                      
a000f198:	e129f003 	msr	CPSR_fc, r3                                   
    }                                                                 
                                                                      
    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
      _ISR_Enable( *level_p );                                        
      return 0;                                                       
a000f19c:	e3a00000 	mov	r0, #0                                        
a000f1a0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
   *  At this point, we know the mutex was not available.  If this thread
   *  is the thread that has locked the mutex, let's see if we are allowed
   *  to nest access.                                                 
   */                                                                 
  if ( _Thread_Is_executing( the_mutex->holder ) ) {                  
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
a000f1a4:	e5932040 	ldr	r2, [r3, #64]	; 0x40                          <== NOT EXECUTED
a000f1a8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000f1ac:	0a000012 	beq	a000f1fc <_CORE_mutex_Seize_interrupt_trylock+0xe8><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  The mutex is not available and the caller must deal with the possibility
   *  of blocking.                                                    
   */                                                                 
  return 1;                                                           
a000f1b0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000f1b4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
a000f1b8:	e592c01c 	ldr	ip, [r2, #28]                                 <== NOT EXECUTED
       */                                                             
    {                                                                 
      Priority_Control  ceiling;                                      
      Priority_Control  current;                                      
                                                                      
      ceiling = the_mutex->Attributes.priority_ceiling;               
a000f1bc:	e593604c 	ldr	r6, [r3, #76]	; 0x4c                          <== NOT EXECUTED
      current = executing->current_priority;                          
a000f1c0:	e5925014 	ldr	r5, [r2, #20]                                 <== NOT EXECUTED
       _Chain_Prepend_unprotected( &executing->lock_mutex,            
                                   &the_mutex->queue.lock_queue );    
       the_mutex->queue.priority_before = executing->current_priority;
#endif                                                                
                                                                      
      executing->resource_count++;                                    
a000f1c4:	e08c7004 	add	r7, ip, r4                                    <== NOT EXECUTED
a000f1c8:	e582701c 	str	r7, [r2, #28]                                 <== NOT EXECUTED
      Priority_Control  ceiling;                                      
      Priority_Control  current;                                      
                                                                      
      ceiling = the_mutex->Attributes.priority_ceiling;               
      current = executing->current_priority;                          
      if ( current == ceiling ) {                                     
a000f1cc:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
a000f1d0:	0a00001d 	beq	a000f24c <_CORE_mutex_Seize_interrupt_trylock+0x138><== NOT EXECUTED
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
      }                                                               
                                                                      
      if ( current > ceiling ) {                                      
a000f1d4:	3a00000f 	bcc	a000f218 <_CORE_mutex_Seize_interrupt_trylock+0x104><== NOT EXECUTED
        );                                                            
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
      }                                                               
      /* if ( current < ceiling ) */ {                                
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
a000f1d8:	e3a05005 	mov	r5, #5                                        <== NOT EXECUTED
a000f1dc:	e5825034 	str	r5, [r2, #52]	; 0x34                          <== NOT EXECUTED
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;                  
a000f1e0:	e5834050 	str	r4, [r3, #80]	; 0x50                          <== NOT EXECUTED
        the_mutex->nest_count = 0;     /* undo locking above */       
a000f1e4:	e5830054 	str	r0, [r3, #84]	; 0x54                          <== NOT EXECUTED
        executing->resource_count--;   /* undo locking above */       
a000f1e8:	e582c01c 	str	ip, [r2, #28]                                 <== NOT EXECUTED
a000f1ec:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000f1f0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
a000f1f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f1f8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
   *  to nest access.                                                 
   */                                                                 
  if ( _Thread_Is_executing( the_mutex->holder ) ) {                  
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {          
      case CORE_MUTEX_NESTING_ACQUIRES:                               
        the_mutex->nest_count++;                                      
a000f1fc:	e5932054 	ldr	r2, [r3, #84]	; 0x54                          <== NOT EXECUTED
a000f200:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000f204:	e5832054 	str	r2, [r3, #84]	; 0x54                          <== NOT EXECUTED
a000f208:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000f20c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
a000f210:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f214:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000f218:	e59f2040 	ldr	r2, [pc, #64]	; a000f260 <_CORE_mutex_Seize_interrupt_trylock+0x14c><== NOT EXECUTED
a000f21c:	e5920000 	ldr	r0, [r2]                                      <== NOT EXECUTED
a000f220:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a000f224:	e5820000 	str	r0, [r2]                                      <== NOT EXECUTED
a000f228:	e5912000 	ldr	r2, [r1]                                      <== NOT EXECUTED
a000f22c:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
      }                                                               
                                                                      
      if ( current > ceiling ) {                                      
        _Thread_Disable_dispatch();                                   
        _ISR_Enable( *level_p );                                      
        _Thread_Change_priority(                                      
a000f230:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000f234:	e593005c 	ldr	r0, [r3, #92]	; 0x5c                          <== NOT EXECUTED
a000f238:	e593104c 	ldr	r1, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a000f23c:	ebfff243 	bl	a000bb50 <_Thread_Change_priority>             <== NOT EXECUTED
          the_mutex->holder,                                          
          the_mutex->Attributes.priority_ceiling,                     
         false                                                        
        );                                                            
        _Thread_Enable_dispatch();                                    
a000f240:	ebfff362 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return 0;                                                     
a000f244:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f248:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
a000f24c:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000f250:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
      ceiling = the_mutex->Attributes.priority_ceiling;               
      current = executing->current_priority;                          
      if ( current == ceiling ) {                                     
        _ISR_Enable( *level_p );                                      
        return 0;                                                     
a000f254:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f258:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000a664 <_CORE_mutex_Surrender>: * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) {
a000a664:	e5d03044 	ldrb	r3, [r0, #68]	; 0x44                         
#else                                                                 
  Objects_Id                         id __attribute__((unused)),      
  CORE_mutex_API_mp_support_callout  api_mutex_mp_support __attribute__((unused))
#endif                                                                
)                                                                     
{                                                                     
a000a668:	e92d4030 	push	{r4, r5, lr}                                 
   *  allowed when the mutex in quetion is FIFO or simple Priority    
   *  discipline.  But Priority Ceiling or Priority Inheritance mutexes
   *  must be released by the thread which acquired them.             
   */                                                                 
                                                                      
  if ( the_mutex->Attributes.only_owner_release ) {                   
a000a66c:	e3530000 	cmp	r3, #0                                        
#else                                                                 
  Objects_Id                         id __attribute__((unused)),      
  CORE_mutex_API_mp_support_callout  api_mutex_mp_support __attribute__((unused))
#endif                                                                
)                                                                     
{                                                                     
a000a670:	e1a04000 	mov	r4, r0                                        
  Thread_Control *the_thread;                                         
  Thread_Control *holder;                                             
                                                                      
  holder = the_mutex->holder;                                         
a000a674:	e590205c 	ldr	r2, [r0, #92]	; 0x5c                          
   *  allowed when the mutex in quetion is FIFO or simple Priority    
   *  discipline.  But Priority Ceiling or Priority Inheritance mutexes
   *  must be released by the thread which acquired them.             
   */                                                                 
                                                                      
  if ( the_mutex->Attributes.only_owner_release ) {                   
a000a678:	0a000005 	beq	a000a694 <_CORE_mutex_Surrender+0x30>         
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
a000a67c:	e59f3120 	ldr	r3, [pc, #288]	; a000a7a4 <_CORE_mutex_Surrender+0x140>
    if ( !_Thread_Is_executing( holder ) )                            
a000a680:	e5933004 	ldr	r3, [r3, #4]                                  
a000a684:	e1520003 	cmp	r2, r3                                        
a000a688:	0a000001 	beq	a000a694 <_CORE_mutex_Surrender+0x30>         
      return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;                 
a000a68c:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
a000a690:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /* XXX already unlocked -- not right status */                      
                                                                      
  if ( !the_mutex->nest_count )                                       
a000a694:	e5940054 	ldr	r0, [r4, #84]	; 0x54                          
a000a698:	e3500000 	cmp	r0, #0                                        
a000a69c:	0a000023 	beq	a000a730 <_CORE_mutex_Surrender+0xcc>         
    return CORE_MUTEX_STATUS_SUCCESSFUL;                              
                                                                      
  the_mutex->nest_count--;                                            
a000a6a0:	e2400001 	sub	r0, r0, #1                                    
                                                                      
  if ( the_mutex->nest_count != 0 ) {                                 
a000a6a4:	e3500000 	cmp	r0, #0                                        
  /* XXX already unlocked -- not right status */                      
                                                                      
  if ( !the_mutex->nest_count )                                       
    return CORE_MUTEX_STATUS_SUCCESSFUL;                              
                                                                      
  the_mutex->nest_count--;                                            
a000a6a8:	e5840054 	str	r0, [r4, #84]	; 0x54                          
                                                                      
  if ( the_mutex->nest_count != 0 ) {                                 
a000a6ac:	1a000020 	bne	a000a734 <_CORE_mutex_Surrender+0xd0>         
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
a000a6b0:	e5943048 	ldr	r3, [r4, #72]	; 0x48                          
                                                                      
  /*                                                                  
   *  Formally release the mutex before possibly transferring it to a 
   *  blocked thread.                                                 
   */                                                                 
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||   
a000a6b4:	e3530002 	cmp	r3, #2                                        
a000a6b8:	0a00001f 	beq	a000a73c <_CORE_mutex_Surrender+0xd8>         
a000a6bc:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a000a6c0:	0a00001d 	beq	a000a73c <_CORE_mutex_Surrender+0xd8>         <== NOT EXECUTED
    if ( holder->resource_count == 0 &&                               
         holder->real_priority != holder->current_priority ) {        
      _Thread_Change_priority( holder, holder->real_priority, true ); 
    }                                                                 
  }                                                                   
  the_mutex->holder    = NULL;                                        
a000a6c4:	e3a05000 	mov	r5, #0                                        
a000a6c8:	e584505c 	str	r5, [r4, #92]	; 0x5c                          
  the_mutex->holder_id = 0;                                           
a000a6cc:	e5845060 	str	r5, [r4, #96]	; 0x60                          
                                                                      
  /*                                                                  
   *  Now we check if another thread was waiting for this mutex.  If so,
   *  transfer the mutex to that thread.                              
   */                                                                 
  if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
a000a6d0:	e1a00004 	mov	r0, r4                                        
a000a6d4:	eb0006fc 	bl	a000c2cc <_Thread_queue_Dequeue>               
a000a6d8:	e2503000 	subs	r3, r0, #0                                   
a000a6dc:	0a00002c 	beq	a000a794 <_CORE_mutex_Surrender+0x130>        
    } else                                                            
#endif                                                                
    {                                                                 
                                                                      
      the_mutex->holder     = the_thread;                             
      the_mutex->holder_id  = the_thread->Object.id;                  
a000a6e0:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
      the_mutex->nest_count = 1;                                      
                                                                      
      switch ( the_mutex->Attributes.discipline ) {                   
a000a6e4:	e5942048 	ldr	r2, [r4, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
    } else                                                            
#endif                                                                
    {                                                                 
                                                                      
      the_mutex->holder     = the_thread;                             
a000a6e8:	e584305c 	str	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
      the_mutex->holder_id  = the_thread->Object.id;                  
a000a6ec:	e5841060 	str	r1, [r4, #96]	; 0x60                          <== NOT EXECUTED
      the_mutex->nest_count = 1;                                      
                                                                      
      switch ( the_mutex->Attributes.discipline ) {                   
a000a6f0:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
#endif                                                                
    {                                                                 
                                                                      
      the_mutex->holder     = the_thread;                             
      the_mutex->holder_id  = the_thread->Object.id;                  
      the_mutex->nest_count = 1;                                      
a000a6f4:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000a6f8:	e5841054 	str	r1, [r4, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
      switch ( the_mutex->Attributes.discipline ) {                   
a000a6fc:	0a00001b 	beq	a000a770 <_CORE_mutex_Surrender+0x10c>        <== NOT EXECUTED
a000a700:	e3520003 	cmp	r2, #3                                        <== NOT EXECUTED
a000a704:	0a000001 	beq	a000a710 <_CORE_mutex_Surrender+0xac>         <== NOT EXECUTED
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a708:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a70c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
a000a710:	e593c01c 	ldr	ip, [r3, #28]                                 <== NOT EXECUTED
          if (the_mutex->Attributes.priority_ceiling <                
a000a714:	e594104c 	ldr	r1, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000a718:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
a000a71c:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
a000a720:	e583c01c 	str	ip, [r3, #28]                                 <== NOT EXECUTED
          if (the_mutex->Attributes.priority_ceiling <                
a000a724:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a728:	21a00005 	movcs	r0, r5                                      <== NOT EXECUTED
          the_thread->resource_count++;                               
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
          if (the_mutex->Attributes.priority_ceiling <                
a000a72c:	3a000014 	bcc	a000a784 <_CORE_mutex_Surrender+0x120>        <== NOT EXECUTED
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
}                                                                     
a000a730:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
          /* Currently no API exercises this behavior. */             
          break;                                                      
      }                                                               
    #else                                                             
      /* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */
      return CORE_MUTEX_STATUS_SUCCESSFUL;                            
a000a734:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a738:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
      _CORE_mutex_Pop_priority( the_mutex, holder );                  
                                                                      
    if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )                 
      return pop_status;                                              
                                                                      
    holder->resource_count--;                                         
a000a73c:	e592301c 	ldr	r3, [r2, #28]                                 
a000a740:	e2433001 	sub	r3, r3, #1                                    
    /*                                                                
     *  Whether or not someone is waiting for the mutex, an           
     *  inherited priority must be lowered if this is the last        
     *  mutex (i.e. resource) this task has.                          
     */                                                               
    if ( holder->resource_count == 0 &&                               
a000a744:	e3530000 	cmp	r3, #0                                        
      _CORE_mutex_Pop_priority( the_mutex, holder );                  
                                                                      
    if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )                 
      return pop_status;                                              
                                                                      
    holder->resource_count--;                                         
a000a748:	e582301c 	str	r3, [r2, #28]                                 
    /*                                                                
     *  Whether or not someone is waiting for the mutex, an           
     *  inherited priority must be lowered if this is the last        
     *  mutex (i.e. resource) this task has.                          
     */                                                               
    if ( holder->resource_count == 0 &&                               
a000a74c:	1affffdc 	bne	a000a6c4 <_CORE_mutex_Surrender+0x60>         
         holder->real_priority != holder->current_priority ) {        
a000a750:	e5921018 	ldr	r1, [r2, #24]                                 
    /*                                                                
     *  Whether or not someone is waiting for the mutex, an           
     *  inherited priority must be lowered if this is the last        
     *  mutex (i.e. resource) this task has.                          
     */                                                               
    if ( holder->resource_count == 0 &&                               
a000a754:	e5923014 	ldr	r3, [r2, #20]                                 
a000a758:	e1510003 	cmp	r1, r3                                        
a000a75c:	0affffd8 	beq	a000a6c4 <_CORE_mutex_Surrender+0x60>         
         holder->real_priority != holder->current_priority ) {        
      _Thread_Change_priority( holder, holder->real_priority, true ); 
a000a760:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a000a764:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000a768:	eb0004f8 	bl	a000bb50 <_Thread_Change_priority>             <== NOT EXECUTED
a000a76c:	eaffffd4 	b	a000a6c4 <_CORE_mutex_Surrender+0x60>           <== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_FIFO:                             
        case CORE_MUTEX_DISCIPLINES_PRIORITY:                         
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
a000a770:	e593201c 	ldr	r2, [r3, #28]                                 <== NOT EXECUTED
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a774:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_FIFO:                             
        case CORE_MUTEX_DISCIPLINES_PRIORITY:                         
          break;                                                      
        case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
a000a778:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a77c:	e583201c 	str	r2, [r3, #28]                                 <== NOT EXECUTED
          break;                                                      
a000a780:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
        case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:                 
          _CORE_mutex_Push_priority( the_mutex, the_thread );         
          the_thread->resource_count++;                               
          if (the_mutex->Attributes.priority_ceiling <                
              the_thread->current_priority){                          
              _Thread_Change_priority(                                
a000a784:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000a788:	eb0004f0 	bl	a000bb50 <_Thread_Change_priority>             <== NOT EXECUTED
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a78c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a790:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
          }                                                           
          break;                                                      
      }                                                               
    }                                                                 
  } else                                                              
    the_mutex->lock = CORE_MUTEX_UNLOCKED;                            
a000a794:	e3a02001 	mov	r2, #1                                        
a000a798:	e5842050 	str	r2, [r4, #80]	; 0x50                          
                                                                      
  return CORE_MUTEX_STATUS_SUCCESSFUL;                                
a000a79c:	e1a00003 	mov	r0, r3                                        
a000a7a0:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

a000a7e0 <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) {
a000a7e0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000a7e4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
a000a7e8:	eb0006b7 	bl	a000c2cc <_Thread_queue_Dequeue>               <== NOT EXECUTED
a000a7ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a7f0:	0a000001 	beq	a000a7fc <_CORE_semaphore_Surrender+0x1c>     <== NOT EXECUTED
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
a000a7f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
a000a7f8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000a7fc:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000a800:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000a804:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
a000a808:	e5943048 	ldr	r3, [r4, #72]	; 0x48                          <== NOT EXECUTED
a000a80c:	e5941040 	ldr	r1, [r4, #64]	; 0x40                          <== NOT EXECUTED
a000a810:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
        the_semaphore->count += 1;                                    
a000a814:	32833001 	addcc	r3, r3, #1                                  <== NOT EXECUTED
a000a818:	35843048 	strcc	r3, [r4, #72]	; 0x48                        <== NOT EXECUTED
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
a000a81c:	23a00004 	movcs	r0, #4                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000a820:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
a000a824:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000ae2c <_Chain_Append_with_empty_check>: bool _Chain_Append_with_empty_check( Chain_Control *chain, Chain_Node *node ) {
a000ae2c:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
a000ae30:	e10fc000 	mrs	ip, CPSR                                      <== NOT EXECUTED
a000ae34:	e38c3080 	orr	r3, ip, #128	; 0x80                           <== NOT EXECUTED
a000ae38:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a000ae3c:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
a000ae40:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
    == _Chain_Immutable_tail( the_chain );                            
a000ae44:	e2802004 	add	r2, r0, #4                                    <== NOT EXECUTED
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a000ae48:	e5801008 	str	r1, [r0, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a000ae4c:	e881000c 	stm	r1, {r2, r3}                                  <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a000ae50:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
a000ae54:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
a000ae58:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a000ae5c:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000ae60:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
  _ISR_Disable( level );                                              
  was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
  _ISR_Enable( level );                                               
                                                                      
  return was_empty;                                                   
}                                                                     
a000ae64:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a000ae68:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a418 <_Chain_Extract>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile (
a000a418:	e10f1000 	mrs	r1, CPSR                                      <== NOT EXECUTED
a000a41c:	e3813080 	orr	r3, r1, #128	; 0x80                           <== NOT EXECUTED
a000a420:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a000a424:	e890000c 	ldm	r0, {r2, r3}                                  <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000a428:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000a42c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000a430:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
    _Chain_Extract_unprotected( node );                               
  _ISR_Enable( level );                                               
}                                                                     
a000a434:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000aeb8 <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) {
a000aeb8:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000aebc:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000aec0:	e3843080 	orr	r3, r4, #128	; 0x80                           <== NOT EXECUTED
a000aec4:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  bool is_empty_now = true;                                           
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_first = head->next;                                 
a000aec8:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  Chain_Node **the_node                                               
)                                                                     
{                                                                     
  bool is_empty_now = true;                                           
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000aecc:	e280c004 	add	ip, r0, #4                                    <== NOT EXECUTED
  Chain_Node *old_first = head->next;                                 
                                                                      
  if ( old_first != tail ) {                                          
a000aed0:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
                                                                      
    *the_node = old_first;                                            
                                                                      
    is_empty_now = new_first == tail;                                 
  } else                                                              
    *the_node = NULL;                                                 
a000aed4:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a000aed8:	05813000 	streq	r3, [r1]                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(    
  Chain_Control *the_chain,                                           
  Chain_Node **the_node                                               
)                                                                     
{                                                                     
  bool is_empty_now = true;                                           
a000aedc:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_first = head->next;                                 
                                                                      
  if ( old_first != tail ) {                                          
a000aee0:	0a000006 	beq	a000af00 <_Chain_Get_with_empty_check+0x48>   <== NOT EXECUTED
    Chain_Node *new_first = old_first->next;                          
a000aee4:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
                                                                      
    head->next = new_first;                                           
a000aee8:	e5802000 	str	r2, [r0]                                      <== NOT EXECUTED
    new_first->previous = head;                                       
a000aeec:	e5820004 	str	r0, [r2, #4]                                  <== NOT EXECUTED
                                                                      
    *the_node = old_first;                                            
                                                                      
    is_empty_now = new_first == tail;                                 
a000aef0:	e15c0002 	cmp	ip, r2                                        <== NOT EXECUTED
a000aef4:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a000aef8:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    Chain_Node *new_first = old_first->next;                          
                                                                      
    head->next = new_first;                                           
    new_first->previous = head;                                       
                                                                      
    *the_node = old_first;                                            
a000aefc:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000af00:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
  _ISR_Disable( level );                                              
  is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
  _ISR_Enable( level );                                               
                                                                      
  return is_empty_now;                                                
}                                                                     
a000af04:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a000af08:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00130c0 <_Chain_Insert>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile (
a00130c0:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a00130c4:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a00130c8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a00130cc:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a00130d0:	e5810004 	str	r0, [r1, #4]                                  <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a00130d4:	e5801000 	str	r1, [r0]                                      <== NOT EXECUTED
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a00130d8:	e5831004 	str	r1, [r3, #4]                                  <== NOT EXECUTED
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a00130dc:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a00130e0:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
    _Chain_Insert_unprotected( after_node, node );                    
  _ISR_Enable( level );                                               
}                                                                     
a00130e4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000af68 <_Chain_Prepend_with_empty_check>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile (
a000af68:	e10fc000 	mrs	ip, CPSR                                      <== NOT EXECUTED
a000af6c:	e38c3080 	orr	r3, ip, #128	; 0x80                           <== NOT EXECUTED
a000af70:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  _ISR_Disable( level );                                              
  was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
  _ISR_Enable( level );                                               
                                                                      
  return was_empty;                                                   
}                                                                     
a000af74:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000af78:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a000af7c:	e5810004 	str	r0, [r1, #4]                                  <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000af80:	e4831004 	str	r1, [r3], #4                                  <== NOT EXECUTED
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a000af84:	e5821004 	str	r1, [r2, #4]                                  <== NOT EXECUTED
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a000af88:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000af8c:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a000af90:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000af94:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a000af98:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
a000af9c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00094cc <_Event_Seize>: rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing;
a00094cc:	e59fc0fc 	ldr	ip, [pc, #252]	; a00095d0 <_Event_Seize+0x104><== NOT EXECUTED
  rtems_event_set  event_in,                                          
  rtems_option     option_set,                                        
  rtems_interval   ticks,                                             
  rtems_event_set *event_out                                          
)                                                                     
{                                                                     
a00094d0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_event_set                   pending_events;                   
  ISR_Level                         level;                            
  RTEMS_API_Control                *api;                              
  Thread_blocking_operation_States  sync_state;                       
                                                                      
  executing = _Thread_Executing;                                      
a00094d4:	e59c4004 	ldr	r4, [ip, #4]                                  <== NOT EXECUTED
  executing->Wait.return_code = RTEMS_SUCCESSFUL;                     
a00094d8:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a00094dc:	e584c034 	str	ip, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
a00094e0:	e594c0f4 	ldr	ip, [r4, #244]	; 0xf4                         <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a00094e4:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
a00094e8:	e3875080 	orr	r5, r7, #128	; 0x80                           <== NOT EXECUTED
a00094ec:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
                                                                      
  _ISR_Disable( level );                                              
  pending_events = api->pending_events;                               
a00094f0:	e59c5000 	ldr	r5, [ip]                                      <== NOT EXECUTED
  seized_events  = _Event_sets_Get( pending_events, event_in );       
                                                                      
  if ( !_Event_sets_Is_empty( seized_events ) &&                      
a00094f4:	e0106005 	ands	r6, r0, r5                                   <== NOT EXECUTED
a00094f8:	0a000003 	beq	a000950c <_Event_Seize+0x40>                  <== NOT EXECUTED
a00094fc:	e1500006 	cmp	r0, r6                                        <== NOT EXECUTED
a0009500:	0a00001f 	beq	a0009584 <_Event_Seize+0xb8>                  <== NOT EXECUTED
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
a0009504:	e3110002 	tst	r1, #2                                        <== NOT EXECUTED
a0009508:	1a00001d 	bne	a0009584 <_Event_Seize+0xb8>                  <== NOT EXECUTED
    _ISR_Enable( level );                                             
    *event_out = seized_events;                                       
    return;                                                           
  }                                                                   
                                                                      
  if ( _Options_Is_no_wait( option_set ) ) {                          
a000950c:	e3110001 	tst	r1, #1                                        <== NOT EXECUTED
a0009510:	1a000016 	bne	a0009570 <_Event_Seize+0xa4>                  <== NOT EXECUTED
   */                                                                 
  executing->Wait.option            = (uint32_t) option_set;          
  executing->Wait.count             = (uint32_t) event_in;            
  executing->Wait.return_argument   = event_out;                      
                                                                      
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
a0009514:	e59f50b8 	ldr	r5, [pc, #184]	; a00095d4 <_Event_Seize+0x108><== NOT EXECUTED
   *  NOTE: Since interrupts are disabled, this isn't that much of an 
   *        issue but better safe than sorry.                         
   */                                                                 
  executing->Wait.option            = (uint32_t) option_set;          
  executing->Wait.count             = (uint32_t) event_in;            
  executing->Wait.return_argument   = event_out;                      
a0009518:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
a000951c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
   *  set properly when we are marked as in the event critical section.
   *                                                                  
   *  NOTE: Since interrupts are disabled, this isn't that much of an 
   *        issue but better safe than sorry.                         
   */                                                                 
  executing->Wait.option            = (uint32_t) option_set;          
a0009520:	e5841030 	str	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
  executing->Wait.count             = (uint32_t) event_in;            
a0009524:	e5840024 	str	r0, [r4, #36]	; 0x24                          <== NOT EXECUTED
  executing->Wait.return_argument   = event_out;                      
                                                                      
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
a0009528:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000952c:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
                                                                      
  if ( ticks ) {                                                      
a0009530:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0009534:	1a000019 	bne	a00095a0 <_Event_Seize+0xd4>                  <== NOT EXECUTED
      NULL                                                            
    );                                                                
    _Watchdog_Insert_ticks( &executing->Timer, ticks );               
  }                                                                   
                                                                      
  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );           
a0009538:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000953c:	e3a01c01 	mov	r1, #256	; 0x100                              <== NOT EXECUTED
a0009540:	eb000cbb 	bl	a000c834 <_Thread_Set_state>                   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0009544:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a0009548:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000954c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  sync_state = _Event_Sync_state;                                     
a0009550:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;         
a0009554:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0009558:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {   
a000955c:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0009560:	0a00000c 	beq	a0009598 <_Event_Seize+0xcc>                  <== NOT EXECUTED
   *  An interrupt completed the thread's blocking request.           
   *  The blocking thread was satisfied by an ISR or timed out.       
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  _Thread_blocking_operation_Cancel( sync_state, executing, level );  
a0009564:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
}                                                                     
a0009568:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
   *  An interrupt completed the thread's blocking request.           
   *  The blocking thread was satisfied by an ISR or timed out.       
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  _Thread_blocking_operation_Cancel( sync_state, executing, level );  
a000956c:	ea000961 	b	a000baf8 <_Thread_blocking_operation_Cancel>    <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0009570:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  if ( _Options_Is_no_wait( option_set ) ) {                          
    _ISR_Enable( level );                                             
    executing->Wait.return_code = RTEMS_UNSATISFIED;                  
a0009574:	e3a0200d 	mov	r2, #13                                       <== NOT EXECUTED
a0009578:	e5842034 	str	r2, [r4, #52]	; 0x34                          <== NOT EXECUTED
    *event_out = seized_events;                                       
a000957c:	e5836000 	str	r6, [r3]                                      <== NOT EXECUTED
    return;                                                           
a0009580:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(               
 rtems_event_set the_event_set,                                       
 rtems_event_set the_mask                                             
)                                                                     
{                                                                     
   return ( the_event_set & ~(the_mask) );                            
a0009584:	e1c55006 	bic	r5, r5, r6                                    <== NOT EXECUTED
  pending_events = api->pending_events;                               
  seized_events  = _Event_sets_Get( pending_events, event_in );       
                                                                      
  if ( !_Event_sets_Is_empty( seized_events ) &&                      
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
    api->pending_events =                                             
a0009588:	e58c5000 	str	r5, [ip]                                      <== NOT EXECUTED
a000958c:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
      _Event_sets_Clear( pending_events, seized_events );             
    _ISR_Enable( level );                                             
    *event_out = seized_events;                                       
a0009590:	e5836000 	str	r6, [r3]                                      <== NOT EXECUTED
    return;                                                           
a0009594:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
a0009598:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
a000959c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;     
                                                                      
  _ISR_Enable( level );                                               
                                                                      
  if ( ticks ) {                                                      
    _Watchdog_Initialize(                                             
a00095a0:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a00095a4:	e59f002c 	ldr	r0, [pc, #44]	; a00095d8 <_Event_Seize+0x10c> <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a00095a8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
a00095ac:	e5841068 	str	r1, [r4, #104]	; 0x68                         <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a00095b0:	e5840064 	str	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a00095b4:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
a00095b8:	e584306c 	str	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a00095bc:	e5842054 	str	r2, [r4, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a00095c0:	e59f0014 	ldr	r0, [pc, #20]	; a00095dc <_Event_Seize+0x110> <== NOT EXECUTED
a00095c4:	e2841048 	add	r1, r4, #72	; 0x48                            <== NOT EXECUTED
a00095c8:	eb000dfa 	bl	a000cdb8 <_Watchdog_Insert>                    <== NOT EXECUTED
a00095cc:	eaffffd9 	b	a0009538 <_Event_Seize+0x6c>                    <== NOT EXECUTED
                                                                      

a0009638 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) {
a0009638:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_event_set     event_condition;                                
  rtems_event_set     seized_events;                                  
  rtems_option        option_set;                                     
  RTEMS_API_Control  *api;                                            
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
a000963c:	e59010f4 	ldr	r1, [r0, #244]	; 0xf4                         <== NOT EXECUTED
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
a0009640:	e5906030 	ldr	r6, [r0, #48]	; 0x30                          <== NOT EXECUTED
 */                                                                   
                                                                      
void _Event_Surrender(                                                
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a0009644:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0009648:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a000964c:	e3803080 	orr	r3, r0, #128	; 0x80                           <== NOT EXECUTED
a0009650:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
                                                                      
  option_set = (rtems_option) the_thread->Wait.option;                
                                                                      
  _ISR_Disable( level );                                              
  pending_events  = api->pending_events;                              
a0009654:	e5912000 	ldr	r2, [r1]                                      <== NOT EXECUTED
  event_condition = (rtems_event_set) the_thread->Wait.count;         
a0009658:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
a000965c:	e013c002 	ands	ip, r3, r2                                   <== NOT EXECUTED
a0009660:	0a000020 	beq	a00096e8 <_Event_Surrender+0xb0>              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
a0009664:	e59f50fc 	ldr	r5, [pc, #252]	; a0009768 <_Event_Surrender+0x130><== NOT EXECUTED
a0009668:	e5957000 	ldr	r7, [r5]                                      <== NOT EXECUTED
a000966c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0009670:	0a000002 	beq	a0009680 <_Event_Surrender+0x48>              <== NOT EXECUTED
a0009674:	e5955004 	ldr	r5, [r5, #4]                                  <== NOT EXECUTED
a0009678:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000967c:	0a000024 	beq	a0009714 <_Event_Surrender+0xdc>              <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (              
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_FOR_EVENT);                    
a0009680:	e5945010 	ldr	r5, [r4, #16]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
a0009684:	e3150c01 	tst	r5, #256	; 0x100                              <== NOT EXECUTED
a0009688:	0a000014 	beq	a00096e0 <_Event_Surrender+0xa8>              <== NOT EXECUTED
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
a000968c:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a0009690:	0a000001 	beq	a000969c <_Event_Surrender+0x64>              <== NOT EXECUTED
a0009694:	e3160002 	tst	r6, #2                                        <== NOT EXECUTED
a0009698:	0a000010 	beq	a00096e0 <_Event_Surrender+0xa8>              <== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
a000969c:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(               
 rtems_event_set the_event_set,                                       
 rtems_event_set the_mask                                             
)                                                                     
{                                                                     
   return ( the_event_set & ~(the_mask) );                            
a00096a0:	e1c2200c 	bic	r2, r2, ip                                    <== NOT EXECUTED
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
a00096a4:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
      the_thread->Wait.count = 0;                                     
a00096a8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00096ac:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
a00096b0:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a00096b4:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a00096b8:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a00096bc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
      _ISR_Flash( level );                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
a00096c0:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a00096c4:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a00096c8:	0a000008 	beq	a00096f0 <_Event_Surrender+0xb8>              <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a00096cc:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a00096d0:	e59f1094 	ldr	r1, [pc, #148]	; a000976c <_Event_Surrender+0x134><== NOT EXECUTED
a00096d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
}                                                                     
a00096d8:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
a00096dc:	ea00095d 	b	a000bc58 <_Thread_Clear_state>                  <== NOT EXECUTED
a00096e0:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a00096e4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
a00096e8:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a00096ec:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
a00096f0:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a00096f4:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a00096f8:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
        _ISR_Enable( level );                                         
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
        (void) _Watchdog_Remove( &the_thread->Timer );                
a00096fc:	e2840048 	add	r0, r4, #72	; 0x48                            <== NOT EXECUTED
a0009700:	eb000e1b 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a0009704:	e59f1060 	ldr	r1, [pc, #96]	; a000976c <_Event_Surrender+0x134><== NOT EXECUTED
a0009708:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
}                                                                     
a000970c:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
a0009710:	ea000950 	b	a000bc58 <_Thread_Clear_state>                  <== NOT EXECUTED
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
a0009714:	e59f5054 	ldr	r5, [pc, #84]	; a0009770 <_Event_Surrender+0x138><== NOT EXECUTED
a0009718:	e5957000 	ldr	r7, [r5]                                      <== NOT EXECUTED
  /*                                                                  
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
a000971c:	e3570002 	cmp	r7, #2                                        <== NOT EXECUTED
a0009720:	0a000002 	beq	a0009730 <_Event_Surrender+0xf8>              <== NOT EXECUTED
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
a0009724:	e5957000 	ldr	r7, [r5]                                      <== NOT EXECUTED
   *  If we are in an ISR and sending to the current thread, then     
   *  we have a critical section issue to deal with.                  
   */                                                                 
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
a0009728:	e3570001 	cmp	r7, #1                                        <== NOT EXECUTED
a000972c:	1affffd3 	bne	a0009680 <_Event_Surrender+0x48>              <== NOT EXECUTED
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
a0009730:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a0009734:	0a000001 	beq	a0009740 <_Event_Surrender+0x108>             <== NOT EXECUTED
a0009738:	e3160002 	tst	r6, #2                                        <== NOT EXECUTED
a000973c:	0a000007 	beq	a0009760 <_Event_Surrender+0x128>             <== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
      the_thread->Wait.count = 0;                                     
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
a0009740:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0009744:	e1c2200c 	bic	r2, r2, ip                                    <== NOT EXECUTED
  if ( _ISR_Is_in_progress() &&                                       
       _Thread_Is_executing( the_thread ) &&                          
       ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||   
        (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
    if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
a0009748:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
      the_thread->Wait.count = 0;                                     
a000974c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0009750:	e5842024 	str	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
a0009754:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;        
a0009758:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a000975c:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
a0009760:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a0009764:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a0009774 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) {
a0009774:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0009778:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
  ISR_Level          level;                                           
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000977c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0009780:	eb000a1b 	bl	a000bff4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a0009784:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0009788:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000978c:	1a000010 	bne	a00097d4 <_Event_Timeout+0x60>                <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0009790:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a0009794:	e3821080 	orr	r1, r2, #128	; 0x80                           <== NOT EXECUTED
a0009798:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
            _ISR_Enable( level );                                     
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
a000979c:	e5803024 	str	r3, [r0, #36]	; 0x24                          <== NOT EXECUTED
        if ( _Thread_Is_executing( the_thread ) ) {                   
a00097a0:	e59f304c 	ldr	r3, [pc, #76]	; a00097f4 <_Event_Timeout+0x80><== NOT EXECUTED
a00097a4:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a00097a8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00097ac:	0a00000a 	beq	a00097dc <_Event_Timeout+0x68>                <== NOT EXECUTED
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
a00097b0:	e3a03006 	mov	r3, #6                                        <== NOT EXECUTED
a00097b4:	e5803034 	str	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a00097b8:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
a00097bc:	e59f1034 	ldr	r1, [pc, #52]	; a00097f8 <_Event_Timeout+0x84><== NOT EXECUTED
a00097c0:	eb000924 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
a00097c4:	e59f3030 	ldr	r3, [pc, #48]	; a00097fc <_Event_Timeout+0x88><== NOT EXECUTED
a00097c8:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a00097cc:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a00097d0:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
}                                                                     
a00097d4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00097d8:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
          if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
a00097dc:	e59f301c 	ldr	r3, [pc, #28]	; a0009800 <_Event_Timeout+0x8c><== NOT EXECUTED
a00097e0:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a00097e4:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;    
a00097e8:	03a01002 	moveq	r1, #2                                      <== NOT EXECUTED
a00097ec:	05831000 	streq	r1, [r3]                                    <== NOT EXECUTED
a00097f0:	eaffffee 	b	a00097b0 <_Event_Timeout+0x3c>                  <== NOT EXECUTED
                                                                      

a000f2cc <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) {
a000f2cc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
a000f2d0:	e1a08002 	mov	r8, r2                                        
  Heap_Statistics *const stats = &heap->stats;                        
  uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
    - HEAP_ALLOC_BONUS;                                               
  uintptr_t const page_size = heap->page_size;                        
a000f2d4:	e5902010 	ldr	r2, [r0, #16]                                 
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000f2d8:	e24dd01c 	sub	sp, sp, #28                                   
a000f2dc:	e1a05001 	mov	r5, r1                                        
  Heap_Block *block = NULL;                                           
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
a000f2e0:	e2911004 	adds	r1, r1, #4                                   
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000f2e4:	e1a07000 	mov	r7, r0                                        
  Heap_Block *block = NULL;                                           
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
a000f2e8:	e58d1000 	str	r1, [sp]                                      
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000f2ec:	e1a0b003 	mov	fp, r3                                        
  Heap_Statistics *const stats = &heap->stats;                        
  uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
    - HEAP_ALLOC_BONUS;                                               
  uintptr_t const page_size = heap->page_size;                        
a000f2f0:	e58d200c 	str	r2, [sp, #12]                                 
  Heap_Block *block = NULL;                                           
  uintptr_t alloc_begin = 0;                                          
  uint32_t search_count = 0;                                          
  bool search_again = false;                                          
                                                                      
  if ( block_size_floor < alloc_size ) {                              
a000f2f4:	2a000078 	bcs	a000f4dc <_Heap_Allocate_aligned_with_boundary+0x210>
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
a000f2f8:	e3530000 	cmp	r3, #0                                        
a000f2fc:	1a000074 	bne	a000f4d4 <_Heap_Allocate_aligned_with_boundary+0x208>
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
a000f300:	e5979008 	ldr	r9, [r7, #8]                                  
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
a000f304:	e1570009 	cmp	r7, r9                                        
a000f308:	0a000073 	beq	a000f4dc <_Heap_Allocate_aligned_with_boundary+0x210>
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
a000f30c:	e59d300c 	ldr	r3, [sp, #12]                                 
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
a000f310:	e2651004 	rsb	r1, r5, #4                                    
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
a000f314:	e3a06001 	mov	r6, #1                                        
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
a000f318:	e2833007 	add	r3, r3, #7                                    
a000f31c:	e58d3010 	str	r3, [sp, #16]                                 
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
a000f320:	e58d1014 	str	r1, [sp, #20]                                 
      /*                                                              
       * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
       * field.  Thus the value is about one unit larger than the real block
       * size.  The greater than operator takes this into account.    
       */                                                             
      if ( block->size_and_flag > block_size_floor ) {                
a000f324:	e599a004 	ldr	sl, [r9, #4]                                  
a000f328:	e59d2000 	ldr	r2, [sp]                                      
a000f32c:	e152000a 	cmp	r2, sl                                        
a000f330:	2a00004e 	bcs	a000f470 <_Heap_Allocate_aligned_with_boundary+0x1a4>
        if ( alignment == 0 ) {                                       
a000f334:	e3580000 	cmp	r8, #0                                        
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(             
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;                  
a000f338:	02894008 	addeq	r4, r9, #8                                  
a000f33c:	0a000051 	beq	a000f488 <_Heap_Allocate_aligned_with_boundary+0x1bc>
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
a000f340:	e5973014 	ldr	r3, [r7, #20]                                 <== NOT EXECUTED
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
a000f344:	e59d1014 	ldr	r1, [sp, #20]                                 <== NOT EXECUTED
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
a000f348:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000f34c:	e3caa001 	bic	sl, sl, #1                                    <== NOT EXECUTED
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
                                                                      
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
a000f350:	e089a00a 	add	sl, r9, sl                                    <== NOT EXECUTED
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
a000f354:	e081400a 	add	r4, r1, sl                                    <== NOT EXECUTED
  if ( stats->max_search < search_count ) {                           
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
a000f358:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
a000f35c:	e0633002 	rsb	r3, r3, r2                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000f360:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t const block_size = _Heap_Block_size( block );             
  uintptr_t const block_end = block_begin + block_size;               
                                                                      
  uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_begin_ceiling = block_end - min_block_size    
a000f364:	e083a00a 	add	sl, r3, sl                                    <== NOT EXECUTED
a000f368:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(             
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;                  
a000f36c:	e2893008 	add	r3, r9, #8                                    <== NOT EXECUTED
a000f370:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000f374:	eb001562 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f378:	e0604004 	rsb	r4, r0, r4                                    <== NOT EXECUTED
  uintptr_t alloc_begin = alloc_end - alloc_size;                     
                                                                      
  alloc_begin = _Heap_Align_down( alloc_begin, alignment );           
                                                                      
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
a000f37c:	e15a0004 	cmp	sl, r4                                        <== NOT EXECUTED
a000f380:	2a000003 	bcs	a000f394 <_Heap_Allocate_aligned_with_boundary+0xc8><== NOT EXECUTED
a000f384:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000f388:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000f38c:	eb00155c 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f390:	e060400a 	rsb	r4, r0, sl                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
a000f394:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
a000f398:	0a000026 	beq	a000f438 <_Heap_Allocate_aligned_with_boundary+0x16c><== NOT EXECUTED
  /* Ensure that the we have a valid new block at the end */          
  if ( alloc_begin > alloc_begin_ceiling ) {                          
    alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment ); 
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
a000f39c:	e084a005 	add	sl, r4, r5                                    <== NOT EXECUTED
a000f3a0:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000f3a4:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a000f3a8:	eb001555 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f3ac:	e060000a 	rsb	r0, r0, sl                                    <== NOT EXECUTED
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
a000f3b0:	e15a0000 	cmp	sl, r0                                        <== NOT EXECUTED
a000f3b4:	93a0a000 	movls	sl, #0                                      <== NOT EXECUTED
a000f3b8:	83a0a001 	movhi	sl, #1                                      <== NOT EXECUTED
a000f3bc:	e1540000 	cmp	r4, r0                                        <== NOT EXECUTED
a000f3c0:	23a0a000 	movcs	sl, #0                                      <== NOT EXECUTED
a000f3c4:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
a000f3c8:	0a00001a 	beq	a000f438 <_Heap_Allocate_aligned_with_boundary+0x16c><== NOT EXECUTED
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
a000f3cc:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
a000f3d0:	e0813005 	add	r3, r1, r5                                    <== NOT EXECUTED
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
      if ( boundary_line < boundary_floor ) {                         
a000f3d4:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
a000f3d8:	958d9018 	strls	r9, [sp, #24]                               <== NOT EXECUTED
a000f3dc:	91a09003 	movls	r9, r3                                      <== NOT EXECUTED
a000f3e0:	9a000002 	bls	a000f3f0 <_Heap_Allocate_aligned_with_boundary+0x124><== NOT EXECUTED
a000f3e4:	ea000021 	b	a000f470 <_Heap_Allocate_aligned_with_boundary+0x1a4><== NOT EXECUTED
a000f3e8:	e1590000 	cmp	r9, r0                                        <== NOT EXECUTED
a000f3ec:	8a00003c 	bhi	a000f4e4 <_Heap_Allocate_aligned_with_boundary+0x218><== NOT EXECUTED
        return 0;                                                     
      }                                                               
      alloc_begin = boundary_line - alloc_size;                       
a000f3f0:	e0654000 	rsb	r4, r5, r0                                    <== NOT EXECUTED
a000f3f4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000f3f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f3fc:	eb001540 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f400:	e0604004 	rsb	r4, r0, r4                                    <== NOT EXECUTED
      alloc_begin = _Heap_Align_down( alloc_begin, alignment );       
      alloc_end = alloc_begin + alloc_size;                           
a000f404:	e084a005 	add	sl, r4, r5                                    <== NOT EXECUTED
a000f408:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000f40c:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a000f410:	eb00153b 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f414:	e060000a 	rsb	r0, r0, sl                                    <== NOT EXECUTED
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
    uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;  
    uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
                                                                      
    while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
a000f418:	e15a0000 	cmp	sl, r0                                        <== NOT EXECUTED
a000f41c:	93a0a000 	movls	sl, #0                                      <== NOT EXECUTED
a000f420:	83a0a001 	movhi	sl, #1                                      <== NOT EXECUTED
a000f424:	e1540000 	cmp	r4, r0                                        <== NOT EXECUTED
a000f428:	23a0a000 	movcs	sl, #0                                      <== NOT EXECUTED
a000f42c:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
a000f430:	1affffec 	bne	a000f3e8 <_Heap_Allocate_aligned_with_boundary+0x11c><== NOT EXECUTED
a000f434:	e59d9018 	ldr	r9, [sp, #24]                                 <== NOT EXECUTED
      boundary_line = _Heap_Align_down( alloc_end, boundary );        
    }                                                                 
  }                                                                   
                                                                      
  /* Ensure that the we have a valid new block at the beginning */    
  if ( alloc_begin >= alloc_begin_floor ) {                           
a000f438:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
a000f43c:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000f440:	8a00000a 	bhi	a000f470 <_Heap_Allocate_aligned_with_boundary+0x1a4><== NOT EXECUTED
a000f444:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
a000f448:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f44c:	eb00152c 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a000f450:	e3e0a007 	mvn	sl, #7                                        <== NOT EXECUTED
a000f454:	e069a00a 	rsb	sl, r9, sl                                    <== NOT EXECUTED
    uintptr_t const alloc_block_begin =                               
      (uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
    uintptr_t const free_size = alloc_block_begin - block_begin;      
                                                                      
    if ( free_size >= min_block_size || free_size == 0 ) {            
a000f458:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a000f45c:	e08aa004 	add	sl, sl, r4                                    <== NOT EXECUTED
a000f460:	e060300a 	rsb	r3, r0, sl                                    <== NOT EXECUTED
a000f464:	e15a0000 	cmp	sl, r0                                        <== NOT EXECUTED
a000f468:	11510003 	cmpne	r1, r3                                      <== NOT EXECUTED
a000f46c:	9a000005 	bls	a000f488 <_Heap_Allocate_aligned_with_boundary+0x1bc><== NOT EXECUTED
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
a000f470:	e5999008 	ldr	r9, [r9, #8]                                  <== NOT EXECUTED
a000f474:	e2863001 	add	r3, r6, #1                                    <== NOT EXECUTED
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
a000f478:	e1570009 	cmp	r7, r9                                        <== NOT EXECUTED
a000f47c:	0a00001d 	beq	a000f4f8 <_Heap_Allocate_aligned_with_boundary+0x22c><== NOT EXECUTED
a000f480:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
a000f484:	eaffffa6 	b	a000f324 <_Heap_Allocate_aligned_with_boundary+0x58><== NOT EXECUTED
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
a000f488:	e3540000 	cmp	r4, #0                                        
a000f48c:	0afffff7 	beq	a000f470 <_Heap_Allocate_aligned_with_boundary+0x1a4>
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
a000f490:	e5972048 	ldr	r2, [r7, #72]	; 0x48                          
    stats->searches += search_count;                                  
a000f494:	e597304c 	ldr	r3, [r7, #76]	; 0x4c                          
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
a000f498:	e1a00007 	mov	r0, r7                                        
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
a000f49c:	e2822001 	add	r2, r2, #1                                    
    stats->searches += search_count;                                  
a000f4a0:	e0833006 	add	r3, r3, r6                                    
    search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
  } while ( search_again );                                           
                                                                      
  if ( alloc_begin != 0 ) {                                           
    /* Statistics */                                                  
    ++stats->allocs;                                                  
a000f4a4:	e5872048 	str	r2, [r7, #72]	; 0x48                          
    stats->searches += search_count;                                  
a000f4a8:	e587304c 	str	r3, [r7, #76]	; 0x4c                          
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
a000f4ac:	e1a01009 	mov	r1, r9                                        
a000f4b0:	e1a02004 	mov	r2, r4                                        
a000f4b4:	e1a03005 	mov	r3, r5                                        
a000f4b8:	ebffedd5 	bl	a000ac14 <_Heap_Block_allocate>                
a000f4bc:	e1a00004 	mov	r0, r4                                        
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
a000f4c0:	e5973044 	ldr	r3, [r7, #68]	; 0x44                          
a000f4c4:	e1530006 	cmp	r3, r6                                        
    stats->max_search = search_count;                                 
a000f4c8:	35876044 	strcc	r6, [r7, #68]	; 0x44                        
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
a000f4cc:	e28dd01c 	add	sp, sp, #28                                   
a000f4d0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
    if ( boundary < alloc_size ) {                                    
a000f4d4:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
a000f4d8:	9a000008 	bls	a000f500 <_Heap_Allocate_aligned_with_boundary+0x234><== NOT EXECUTED
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
a000f4dc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f4e0:	eafffff9 	b	a000f4cc <_Heap_Allocate_aligned_with_boundary+0x200><== NOT EXECUTED
a000f4e4:	e59d9018 	ldr	r9, [sp, #24]                                 <== NOT EXECUTED
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
a000f4e8:	e2863001 	add	r3, r6, #1                                    <== NOT EXECUTED
a000f4ec:	e5999008 	ldr	r9, [r9, #8]                                  <== NOT EXECUTED
                                                                      
  do {                                                                
    Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );  
                                                                      
    block = _Heap_Free_list_first( heap );                            
    while ( block != free_list_tail ) {                               
a000f4f0:	e1570009 	cmp	r7, r9                                        <== NOT EXECUTED
a000f4f4:	1affffe1 	bne	a000f480 <_Heap_Allocate_aligned_with_boundary+0x1b4><== NOT EXECUTED
a000f4f8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f4fc:	eaffffef 	b	a000f4c0 <_Heap_Allocate_aligned_with_boundary+0x1f4><== NOT EXECUTED
    if ( boundary < alloc_size ) {                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
      alignment = page_size;                                          
a000f500:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000f504:	01a08002 	moveq	r8, r2                                      <== NOT EXECUTED
a000f508:	eaffff7c 	b	a000f300 <_Heap_Allocate_aligned_with_boundary+0x34><== NOT EXECUTED
                                                                      

a000ac14 <_Heap_Block_allocate>: Heap_Control *heap, Heap_Block *block, uintptr_t alloc_begin, uintptr_t alloc_size ) {
a000ac14:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000ac18:	e5917004 	ldr	r7, [r1, #4]                                  
  Heap_Control *heap,                                                 
  Heap_Block *block,                                                  
  uintptr_t alloc_begin,                                              
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
a000ac1c:	e1a05001 	mov	r5, r1                                        
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(             
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;                  
a000ac20:	e2426008 	sub	r6, r2, #8                                    
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000ac24:	e3c71001 	bic	r1, r7, #1                                    
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000ac28:	e0858001 	add	r8, r5, r1                                    
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000ac2c:	e598c004 	ldr	ip, [r8, #4]                                  
a000ac30:	e1a0a003 	mov	sl, r3                                        
a000ac34:	e1a04000 	mov	r4, r0                                        
                                                                      
  Heap_Block *free_list_anchor = NULL;                                
                                                                      
  _HAssert( alloc_area_begin <= alloc_begin );                        
                                                                      
  if ( _Heap_Is_free( block ) ) {                                     
a000ac38:	e31c0001 	tst	ip, #1                                        
)                                                                     
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  uintptr_t const alloc_area_begin = _Heap_Alloc_area_of_block( block );
  uintptr_t const alloc_area_offset = alloc_begin - alloc_area_begin; 
a000ac3c:	e0653006 	rsb	r3, r5, r6                                    
    /* Statistics */                                                  
    --stats->free_blocks;                                             
    ++stats->used_blocks;                                             
    stats->free_size -= _Heap_Block_size( block );                    
  } else {                                                            
    free_list_anchor = _Heap_Free_list_head( heap );                  
a000ac40:	11a09000 	movne	r9, r0                                      
                                                                      
  Heap_Block *free_list_anchor = NULL;                                
                                                                      
  _HAssert( alloc_area_begin <= alloc_begin );                        
                                                                      
  if ( _Heap_Is_free( block ) ) {                                     
a000ac44:	1a00000c 	bne	a000ac7c <_Heap_Block_allocate+0x68>          
    free_list_anchor = block->prev;                                   
                                                                      
    _Heap_Free_list_remove( block );                                  
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a000ac48:	e590e038 	ldr	lr, [r0, #56]	; 0x38                          
    ++stats->used_blocks;                                             
a000ac4c:	e590c040 	ldr	ip, [r0, #64]	; 0x40                          
    stats->free_size -= _Heap_Block_size( block );                    
a000ac50:	e590b030 	ldr	fp, [r0, #48]	; 0x30                          
  Heap_Block *free_list_anchor = NULL;                                
                                                                      
  _HAssert( alloc_area_begin <= alloc_begin );                        
                                                                      
  if ( _Heap_Is_free( block ) ) {                                     
    free_list_anchor = block->prev;                                   
a000ac54:	e595900c 	ldr	r9, [r5, #12]                                 
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000ac58:	e5950008 	ldr	r0, [r5, #8]                                  
    free_list_anchor = block->prev;                                   
                                                                      
    _Heap_Free_list_remove( block );                                  
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a000ac5c:	e24ee001 	sub	lr, lr, #1                                    
    ++stats->used_blocks;                                             
a000ac60:	e28cc001 	add	ip, ip, #1                                    
    stats->free_size -= _Heap_Block_size( block );                    
a000ac64:	e061100b 	rsb	r1, r1, fp                                    
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
  Heap_Block *prev = block->prev;                                     
                                                                      
  prev->next = next;                                                  
a000ac68:	e5890008 	str	r0, [r9, #8]                                  
  next->prev = prev;                                                  
a000ac6c:	e580900c 	str	r9, [r0, #12]                                 
    free_list_anchor = block->prev;                                   
                                                                      
    _Heap_Free_list_remove( block );                                  
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a000ac70:	e584e038 	str	lr, [r4, #56]	; 0x38                          
    ++stats->used_blocks;                                             
a000ac74:	e584c040 	str	ip, [r4, #64]	; 0x40                          
    stats->free_size -= _Heap_Block_size( block );                    
a000ac78:	e5841030 	str	r1, [r4, #48]	; 0x30                          
  } else {                                                            
    free_list_anchor = _Heap_Free_list_head( heap );                  
  }                                                                   
                                                                      
  if ( alloc_area_offset < heap->page_size ) {                        
a000ac7c:	e5941010 	ldr	r1, [r4, #16]                                 
a000ac80:	e1530001 	cmp	r3, r1                                        
a000ac84:	3a000027 	bcc	a000ad28 <_Heap_Block_allocate+0x114>         
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000ac88:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a000ac8c:	eb00271c 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
                                                                      
  _HAssert( block_size >= heap->min_block_size );                     
  _HAssert( new_block_size >= heap->min_block_size );                 
                                                                      
  /* Statistics */                                                    
  stats->free_size += block_size;                                     
a000ac90:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a000ac94:	e0606006 	rsb	r6, r0, r6                                    <== NOT EXECUTED
    _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );        
  uintptr_t const new_block_begin = (uintptr_t) new_block;            
  uintptr_t const new_block_size = block_end - new_block_begin;       
                                                                      
  block_end = new_block_begin;                                        
  block_size = block_end - block_begin;                               
a000ac98:	e0651006 	rsb	r1, r5, r6                                    <== NOT EXECUTED
                                                                      
  _HAssert( block_size >= heap->min_block_size );                     
  _HAssert( new_block_size >= heap->min_block_size );                 
                                                                      
  /* Statistics */                                                    
  stats->free_size += block_size;                                     
a000ac9c:	e0833001 	add	r3, r3, r1                                    <== NOT EXECUTED
                                                                      
  if ( _Heap_Is_prev_used( block ) ) {                                
a000aca0:	e3170001 	tst	r7, #1                                        <== NOT EXECUTED
  uintptr_t block_end = block_begin + block_size;                     
                                                                      
  Heap_Block *const new_block =                                       
    _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );        
  uintptr_t const new_block_begin = (uintptr_t) new_block;            
  uintptr_t const new_block_size = block_end - new_block_begin;       
a000aca4:	e0668008 	rsb	r8, r6, r8                                    <== NOT EXECUTED
                                                                      
  _HAssert( block_size >= heap->min_block_size );                     
  _HAssert( new_block_size >= heap->min_block_size );                 
                                                                      
  /* Statistics */                                                    
  stats->free_size += block_size;                                     
a000aca8:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
  if ( _Heap_Is_prev_used( block ) ) {                                
a000acac:	1a000013 	bne	a000ad00 <_Heap_Block_allocate+0xec>          <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(                    
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block - block->prev_size);       
a000acb0:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
  } else {                                                            
    Heap_Block *const prev_block = _Heap_Prev_block( block );         
    uintptr_t const prev_block_size = _Heap_Block_size( prev_block ); 
                                                                      
    block = prev_block;                                               
    block_size += prev_block_size;                                    
a000acb4:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
a000acb8:	e0635005 	rsb	r5, r3, r5                                    <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000acbc:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
a000acc0:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
a000acc4:	e0811003 	add	r1, r1, r3                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;           
a000acc8:	e3813001 	orr	r3, r1, #1                                    <== NOT EXECUTED
a000accc:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  new_block->prev_size = block_size;                                  
a000acd0:	e5861000 	str	r1, [r6]                                      <== NOT EXECUTED
  new_block->size_and_flag = new_block_size;                          
                                                                      
  _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 
a000acd4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000acd8:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;           
                                                                      
  new_block->prev_size = block_size;                                  
  new_block->size_and_flag = new_block_size;                          
a000acdc:	e5868004 	str	r8, [r6, #4]                                  <== NOT EXECUTED
                                                                      
  _Heap_Block_split( heap, new_block, free_list_anchor, alloc_size ); 
a000ace0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000ace4:	ebffff17 	bl	a000a948 <_Heap_Block_split>                   <== NOT EXECUTED
      alloc_size                                                      
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->min_free_size > stats->free_size ) {                    
a000ace8:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
a000acec:	e5942034 	ldr	r2, [r4, #52]	; 0x34                          <== NOT EXECUTED
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000acf0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
      alloc_size                                                      
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->min_free_size > stats->free_size ) {                    
a000acf4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    stats->min_free_size = stats->free_size;                          
a000acf8:	85843034 	strhi	r3, [r4, #52]	; 0x34                        <== NOT EXECUTED
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000acfc:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    _Heap_Free_list_insert_after( free_list_anchor, block );          
                                                                      
    free_list_anchor = block;                                         
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
a000ad00:	e5940038 	ldr	r0, [r4, #56]	; 0x38                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(               
  Heap_Block *block_before,                                           
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
a000ad04:	e5993008 	ldr	r3, [r9, #8]                                  <== NOT EXECUTED
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
a000ad08:	e585900c 	str	r9, [r5, #12]                                 <== NOT EXECUTED
a000ad0c:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
a000ad10:	e5853008 	str	r3, [r5, #8]                                  <== NOT EXECUTED
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
a000ad14:	e583500c 	str	r5, [r3, #12]                                 <== NOT EXECUTED
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
a000ad18:	e5895008 	str	r5, [r9, #8]                                  <== NOT EXECUTED
a000ad1c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000ad20:	e5840038 	str	r0, [r4, #56]	; 0x38                          <== NOT EXECUTED
a000ad24:	eaffffe7 	b	a000acc8 <_Heap_Block_allocate+0xb4>            <== NOT EXECUTED
  Heap_Block *block,                                                  
  Heap_Block *free_list_anchor,                                       
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
  _Heap_Block_split( heap, block, free_list_anchor, alloc_size );     
a000ad28:	e1a00004 	mov	r0, r4                                        
a000ad2c:	e1a02009 	mov	r2, r9                                        
a000ad30:	e083300a 	add	r3, r3, sl                                    
a000ad34:	e1a01005 	mov	r1, r5                                        
a000ad38:	ebffff02 	bl	a000a948 <_Heap_Block_split>                   
      alloc_size                                                      
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->min_free_size > stats->free_size ) {                    
a000ad3c:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          
a000ad40:	e5942034 	ldr	r2, [r4, #52]	; 0x34                          
  Heap_Block *block,                                                  
  Heap_Block *free_list_anchor,                                       
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
  _Heap_Block_split( heap, block, free_list_anchor, alloc_size );     
a000ad44:	e1a06005 	mov	r6, r5                                        
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000ad48:	e1a00006 	mov	r0, r6                                        
      alloc_size                                                      
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->min_free_size > stats->free_size ) {                    
a000ad4c:	e1520003 	cmp	r2, r3                                        
    stats->min_free_size = stats->free_size;                          
a000ad50:	85843034 	strhi	r3, [r4, #52]	; 0x34                        
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000ad54:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
                                                                      

a000a948 <_Heap_Block_split>: Heap_Control *heap, Heap_Block *block, Heap_Block *free_list_anchor, uintptr_t alloc_size ) {
a000a948:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
a000a94c:	e5906014 	ldr	r6, [r0, #20]                                 
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  uintptr_t const page_size = heap->page_size;                        
a000a950:	e5907010 	ldr	r7, [r0, #16]                                 
  Heap_Control *heap,                                                 
  Heap_Block *block,                                                  
  Heap_Block *free_list_anchor,                                       
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
a000a954:	e1a05001 	mov	r5, r1                                        
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
  uintptr_t const min_alloc_size = min_block_size - HEAP_BLOCK_HEADER_SIZE;
a000a958:	e2468008 	sub	r8, r6, #8                                    
  return heap->stats.size;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )  
{                                                                     
  return a > b ? a : b;                                               
a000a95c:	e1530008 	cmp	r3, r8                                        
a000a960:	21a08003 	movcs	r8, r3                                      
                                                                      
  uintptr_t const block_size = _Heap_Block_size( block );             
                                                                      
  uintptr_t const used_size =                                         
a000a964:	e2888008 	add	r8, r8, #8                                    
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(                        
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
a000a968:	e1a01007 	mov	r1, r7                                        
  Heap_Control *heap,                                                 
  Heap_Block *block,                                                  
  Heap_Block *free_list_anchor,                                       
  uintptr_t alloc_size                                                
)                                                                     
{                                                                     
a000a96c:	e1a04000 	mov	r4, r0                                        
a000a970:	e1a00008 	mov	r0, r8                                        
a000a974:	e1a09002 	mov	r9, r2                                        
a000a978:	eb0027e1 	bl	a0014904 <__umodsi3>                           
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000a97c:	e595a004 	ldr	sl, [r5, #4]                                  
                                                                      
  if ( remainder != 0 ) {                                             
a000a980:	e3500000 	cmp	r0, #0                                        
    return value - remainder + alignment;                             
a000a984:	10887007 	addne	r7, r8, r7                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000a988:	e3ca2001 	bic	r2, sl, #1                                    
                                                                      
  uintptr_t const used_size =                                         
    _Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE; 
  uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
                                                                      
  uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
a000a98c:	e2823004 	add	r3, r2, #4                                    
  uintptr_t remainder = value % alignment;                            
                                                                      
  if ( remainder != 0 ) {                                             
    return value - remainder + alignment;                             
  } else {                                                            
    return value;                                                     
a000a990:	01a07008 	moveq	r7, r8                                      
  uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
a000a994:	e2866004 	add	r6, r6, #4                                    
                                                                      
  uintptr_t const used_size =                                         
    _Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE; 
  uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
                                                                      
  uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
a000a998:	e0688003 	rsb	r8, r8, r3                                    
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
                                                                      
  if ( remainder != 0 ) {                                             
    return value - remainder + alignment;                             
a000a99c:	10607007 	rsbne	r7, r0, r7                                  
  Heap_Block *next_block = _Heap_Block_at( block, block_size );       
                                                                      
  _HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );             
  _HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS ); 
                                                                      
  if ( free_size >= free_size_limit ) {                               
a000a9a0:	e1580006 	cmp	r8, r6                                        
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000a9a4:	e0853002 	add	r3, r5, r2                                    
a000a9a8:	3a00001c 	bcc	a000aa20 <_Heap_Block_split+0xd8>             
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a000a9ac:	e20aa001 	and	sl, sl, #1                                    
                                                                      
  block->size_and_flag = size | flag;                                 
a000a9b0:	e187a00a 	orr	sl, r7, sl                                    
a000a9b4:	e585a004 	str	sl, [r5, #4]                                  
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000a9b8:	e5931004 	ldr	r1, [r3, #4]                                  
    _HAssert( used_block_size + free_block_size == block_size );      
                                                                      
    _Heap_Block_set_size( block, used_block_size );                   
                                                                      
    /* Statistics */                                                  
    stats->free_size += free_block_size;                              
a000a9bc:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          
  _HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );             
  _HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS ); 
                                                                      
  if ( free_size >= free_size_limit ) {                               
    Heap_Block *const free_block = _Heap_Block_at( block, used_block_size );
    uintptr_t free_block_size = block_size - used_block_size;         
a000a9c0:	e0672002 	rsb	r2, r7, r2                                    
a000a9c4:	e3c11001 	bic	r1, r1, #1                                    
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000a9c8:	e083c001 	add	ip, r3, r1                                    
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000a9cc:	e59cc004 	ldr	ip, [ip, #4]                                  
    _HAssert( used_block_size + free_block_size == block_size );      
                                                                      
    _Heap_Block_set_size( block, used_block_size );                   
                                                                      
    /* Statistics */                                                  
    stats->free_size += free_block_size;                              
a000a9d0:	e0800002 	add	r0, r0, r2                                    
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000a9d4:	e0875005 	add	r5, r7, r5                                    
                                                                      
    if ( _Heap_Is_used( next_block ) ) {                              
a000a9d8:	e31c0001 	tst	ip, #1                                        
    _HAssert( used_block_size + free_block_size == block_size );      
                                                                      
    _Heap_Block_set_size( block, used_block_size );                   
                                                                      
    /* Statistics */                                                  
    stats->free_size += free_block_size;                              
a000a9dc:	e5840030 	str	r0, [r4, #48]	; 0x30                          
                                                                      
    if ( _Heap_Is_used( next_block ) ) {                              
a000a9e0:	1a000012 	bne	a000aa30 <_Heap_Block_split+0xe8>             
  }                                                                   
                                                                      
  _Heap_Protection_block_initialize( heap, block );                   
                                                                      
  return block;                                                       
}                                                                     
a000a9e4:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a000a9e8:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
    } else {                                                          
      uintptr_t const next_block_size = _Heap_Block_size( next_block );
                                                                      
      _Heap_Free_list_replace( next_block, free_block );              
                                                                      
      free_block_size += next_block_size;                             
a000a9ec:	e0822001 	add	r2, r2, r1                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
a000a9f0:	e5850008 	str	r0, [r5, #8]                                  <== NOT EXECUTED
  new_block->prev = prev;                                             
a000a9f4:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
                                                                      
  next->prev = new_block;                                             
  prev->next = new_block;                                             
a000a9f8:	e5835008 	str	r5, [r3, #8]                                  <== NOT EXECUTED
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
  new_block->prev = prev;                                             
                                                                      
  next->prev = new_block;                                             
a000a9fc:	e580500c 	str	r5, [r0, #12]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000aa00:	e0823005 	add	r3, r2, r5                                    <== NOT EXECUTED
                                                                      
      next_block = _Heap_Block_at( free_block, free_block_size );     
    }                                                                 
                                                                      
    free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
a000aa04:	e3821001 	orr	r1, r2, #1                                    
a000aa08:	e5851004 	str	r1, [r5, #4]                                  
                                                                      
    next_block->prev_size = free_block_size;                          
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
a000aa0c:	e5931004 	ldr	r1, [r3, #4]                                  
      next_block = _Heap_Block_at( free_block, free_block_size );     
    }                                                                 
                                                                      
    free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
                                                                      
    next_block->prev_size = free_block_size;                          
a000aa10:	e5832000 	str	r2, [r3]                                      
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
a000aa14:	e3c12001 	bic	r2, r1, #1                                    
a000aa18:	e5832004 	str	r2, [r3, #4]                                  
a000aa1c:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
                                                                      
    _Heap_Protection_block_initialize( heap, free_block );            
  } else {                                                            
    next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                
a000aa20:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a000aa24:	e3822001 	orr	r2, r2, #1                                    <== NOT EXECUTED
a000aa28:	e5832004 	str	r2, [r3, #4]                                  <== NOT EXECUTED
a000aa2c:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      
    if ( _Heap_Is_used( next_block ) ) {                              
      _Heap_Free_list_insert_after( free_list_anchor, free_block );   
                                                                      
      /* Statistics */                                                
      ++stats->free_blocks;                                           
a000aa30:	e5940038 	ldr	r0, [r4, #56]	; 0x38                          
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(               
  Heap_Block *block_before,                                           
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
a000aa34:	e5991008 	ldr	r1, [r9, #8]                                  
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
a000aa38:	e585900c 	str	r9, [r5, #12]                                 
a000aa3c:	e2800001 	add	r0, r0, #1                                    
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
a000aa40:	e5851008 	str	r1, [r5, #8]                                  
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
a000aa44:	e581500c 	str	r5, [r1, #12]                                 
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
a000aa48:	e5895008 	str	r5, [r9, #8]                                  
a000aa4c:	e5840038 	str	r0, [r4, #56]	; 0x38                          
a000aa50:	eaffffeb 	b	a000aa04 <_Heap_Block_split+0xbc>               
                                                                      

a000f858 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) {
a000f858:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a000f85c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  uintptr_t const free_size = stats->free_size;                       
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
a000f860:	e0916002 	adds	r6, r1, r2                                   <== NOT EXECUTED
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
a000f864:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
a000f868:	e5908020 	ldr	r8, [r0, #32]                                 <== NOT EXECUTED
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
  uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
  uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
  uintptr_t const free_size = stats->free_size;                       
a000f86c:	e5951030 	ldr	r1, [r5, #48]	; 0x30                          <== NOT EXECUTED
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
a000f870:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
a000f874:	e24dd024 	sub	sp, sp, #36	; 0x24                            <== NOT EXECUTED
  Heap_Block *start_block = first_block;                              
  Heap_Block *merge_below_block = NULL;                               
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
a000f878:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
  Heap_Control *heap,                                                 
  void *extend_area_begin_ptr,                                        
  uintptr_t extend_area_size,                                         
  uintptr_t *extended_size_ptr                                        
)                                                                     
{                                                                     
a000f87c:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
  Heap_Block *extend_last_block = NULL;                               
  uintptr_t const page_size = heap->page_size;                        
a000f880:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
  Heap_Block *start_block = first_block;                              
  Heap_Block *merge_below_block = NULL;                               
  Heap_Block *merge_above_block = NULL;                               
  Heap_Block *link_below_block = NULL;                                
  Heap_Block *link_above_block = NULL;                                
  Heap_Block *extend_first_block = NULL;                              
a000f884:	e58d7020 	str	r7, [sp, #32]                                 <== NOT EXECUTED
  Heap_Block *extend_last_block = NULL;                               
a000f888:	e58d701c 	str	r7, [sp, #28]                                 <== NOT EXECUTED
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
a000f88c:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
  uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
  uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
  uintptr_t const free_size = stats->free_size;                       
a000f890:	e58d1018 	str	r1, [sp, #24]                                 <== NOT EXECUTED
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
    return false;                                                     
a000f894:	21a00007 	movcs	r0, r7                                      <== NOT EXECUTED
  uintptr_t const free_size = stats->free_size;                       
  uintptr_t extend_first_block_size = 0;                              
  uintptr_t extended_size = 0;                                        
  bool extend_area_ok = false;                                        
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
a000f898:	3a000001 	bcc	a000f8a4 <_Heap_Extend+0x4c>                  <== NOT EXECUTED
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
}                                                                     
a000f89c:	e28dd024 	add	sp, sp, #36	; 0x24                            <== NOT EXECUTED
a000f8a0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
  if ( extend_area_end < extend_area_begin ) {                        
    return false;                                                     
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
a000f8a4:	e28dc020 	add	ip, sp, #32                                   <== NOT EXECUTED
a000f8a8:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a000f8ac:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a000f8b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f8b4:	e28dc01c 	add	ip, sp, #28                                   <== NOT EXECUTED
a000f8b8:	e59d2008 	ldr	r2, [sp, #8]                                  <== NOT EXECUTED
a000f8bc:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a000f8c0:	ebffed3c 	bl	a000adb8 <_Heap_Get_first_and_last_block>      <== NOT EXECUTED
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
a000f8c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000f8c8:	0afffff3 	beq	a000f89c <_Heap_Extend+0x44>                  <== NOT EXECUTED
a000f8cc:	e1a09008 	mov	r9, r8                                        <== NOT EXECUTED
a000f8d0:	e1a0b007 	mov	fp, r7                                        <== NOT EXECUTED
a000f8d4:	e58d700c 	str	r7, [sp, #12]                                 <== NOT EXECUTED
a000f8d8:	e58d7014 	str	r7, [sp, #20]                                 <== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  do {                                                                
    uintptr_t const sub_area_begin = (start_block != first_block) ?   
      (uintptr_t) start_block : heap->area_begin;                     
a000f8dc:	e1590008 	cmp	r9, r8                                        <== NOT EXECUTED
a000f8e0:	05953018 	ldreq	r3, [r5, #24]                               <== NOT EXECUTED
    uintptr_t const sub_area_end = start_block->prev_size;            
a000f8e4:	e599a000 	ldr	sl, [r9]                                      <== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  do {                                                                
    uintptr_t const sub_area_begin = (start_block != first_block) ?   
      (uintptr_t) start_block : heap->area_begin;                     
a000f8e8:	11a03009 	movne	r3, r9                                      <== NOT EXECUTED
    uintptr_t const sub_area_end = start_block->prev_size;            
    Heap_Block *const end_block =                                     
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
a000f8ec:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a000f8f0:	3154000a 	cmpcc	r4, sl                                      <== NOT EXECUTED
a000f8f4:	3a00006c 	bcc	a000faac <_Heap_Extend+0x254>                 <== NOT EXECUTED
      sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
    ) {                                                               
      return false;                                                   
    }                                                                 
                                                                      
    if ( extend_area_end == sub_area_begin ) {                        
a000f8f8:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a000f8fc:	058d9014 	streq	r9, [sp, #20]                               <== NOT EXECUTED
a000f900:	0a000001 	beq	a000f90c <_Heap_Extend+0xb4>                  <== NOT EXECUTED
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
a000f904:	e156000a 	cmp	r6, sl                                        <== NOT EXECUTED
a000f908:	31a0b009 	movcc	fp, r9                                      <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000f90c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000f910:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
a000f914:	eb00154f 	bl	a0014e58 <__umodsi3>                           <== NOT EXECUTED
a000f918:	e24a3008 	sub	r3, sl, #8                                    <== NOT EXECUTED
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
a000f91c:	e15a0004 	cmp	sl, r4                                        <== NOT EXECUTED
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a000f920:	e0603003 	rsb	r3, r0, r3                                    <== NOT EXECUTED
      start_block->prev_size = extend_area_end;                       
a000f924:	05896000 	streq	r6, [r9]                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(           
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
a000f928:	058d300c 	streq	r3, [sp, #12]                               <== NOT EXECUTED
      merge_below_block = start_block;                                
    } else if ( extend_area_end < sub_area_end ) {                    
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
a000f92c:	0a000001 	beq	a000f938 <_Heap_Extend+0xe0>                  <== NOT EXECUTED
a000f930:	e154000a 	cmp	r4, sl                                        <== NOT EXECUTED
a000f934:	81a07003 	movhi	r7, r3                                      <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000f938:	e5939004 	ldr	r9, [r3, #4]                                  <== NOT EXECUTED
a000f93c:	e3c99001 	bic	r9, r9, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000f940:	e0839009 	add	r9, r3, r9                                    <== NOT EXECUTED
    } else if ( sub_area_end < extend_area_begin ) {                  
      link_above_block = end_block;                                   
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
a000f944:	e1580009 	cmp	r8, r9                                        <== NOT EXECUTED
a000f948:	1affffe3 	bne	a000f8dc <_Heap_Extend+0x84>                  <== NOT EXECUTED
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
a000f94c:	e5953018 	ldr	r3, [r5, #24]                                 <== NOT EXECUTED
a000f950:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    heap->area_begin = extend_area_begin;                             
a000f954:	35854018 	strcc	r4, [r5, #24]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
  } while ( start_block != first_block );                             
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
a000f958:	3a000002 	bcc	a000f968 <_Heap_Extend+0x110>                 <== NOT EXECUTED
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
a000f95c:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
a000f960:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
    heap->area_end = extend_area_end;                                 
a000f964:	8585601c 	strhi	r6, [r5, #28]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
a000f968:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
a000f96c:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
a000f970:	e595c020 	ldr	ip, [r5, #32]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
a000f974:	e5836000 	str	r6, [r3]                                      <== NOT EXECUTED
    heap->area_begin = extend_area_begin;                             
  } else if ( heap->area_end < extend_area_end ) {                    
    heap->area_end = extend_area_end;                                 
  }                                                                   
                                                                      
  extend_first_block_size =                                           
a000f978:	e0631002 	rsb	r1, r3, r2                                    <== NOT EXECUTED
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
a000f97c:	e3810001 	orr	r0, r1, #1                                    <== NOT EXECUTED
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
a000f980:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
a000f984:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
a000f988:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
                                                                      
  extend_first_block_size =                                           
    (uintptr_t) extend_last_block - (uintptr_t) extend_first_block;   
                                                                      
  extend_first_block->prev_size = extend_area_end;                    
  extend_first_block->size_and_flag =                                 
a000f98c:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
  _Heap_Protection_block_initialize( heap, extend_first_block );      
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
a000f990:	e5821004 	str	r1, [r2, #4]                                  <== NOT EXECUTED
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
    heap->first_block = extend_first_block;                           
a000f994:	85853020 	strhi	r3, [r5, #32]                               <== NOT EXECUTED
                                                                      
  extend_last_block->prev_size = extend_first_block_size;             
  extend_last_block->size_and_flag = 0;                               
  _Heap_Protection_block_initialize( heap, extend_last_block );       
                                                                      
  if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
a000f998:	8a000002 	bhi	a000f9a8 <_Heap_Extend+0x150>                 <== NOT EXECUTED
    heap->first_block = extend_first_block;                           
  } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
a000f99c:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
a000f9a0:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
    heap->last_block = extend_last_block;                             
a000f9a4:	35852024 	strcc	r2, [r5, #36]	; 0x24                        <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
a000f9a8:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
a000f9ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000f9b0:	0a000050 	beq	a000faf8 <_Heap_Extend+0x2a0>                 <== NOT EXECUTED
  Heap_Control *heap,                                                 
  uintptr_t extend_area_begin,                                        
  Heap_Block *first_block                                             
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
a000f9b4:	e5958010 	ldr	r8, [r5, #16]                                 <== NOT EXECUTED
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
a000f9b8:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(                        
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
a000f9bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f9c0:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000f9c4:	eb001523 	bl	a0014e58 <__umodsi3>                           <== NOT EXECUTED
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
a000f9c8:	e59dc014 	ldr	ip, [sp, #20]                                 <== NOT EXECUTED
                                                                      
  if ( remainder != 0 ) {                                             
a000f9cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return value - remainder + alignment;                             
a000f9d0:	10844008 	addne	r4, r4, r8                                  <== NOT EXECUTED
a000f9d4:	10604004 	rsbne	r4, r0, r4                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
a000f9d8:	e2441008 	sub	r1, r4, #8                                    <== NOT EXECUTED
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
a000f9dc:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
  uintptr_t const new_first_block_alloc_begin =                       
    _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const new_first_block_begin =                             
    new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;             
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
a000f9e0:	e061300c 	rsb	r3, r1, ip                                    <== NOT EXECUTED
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
  new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
a000f9e4:	e3833001 	orr	r3, r3, #1                                    <== NOT EXECUTED
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
  uintptr_t const new_first_block_size =                              
    first_block_begin - new_first_block_begin;                        
  Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
                                                                      
  new_first_block->prev_size = first_block->prev_size;                
a000f9e8:	e5042008 	str	r2, [r4, #-8]                                 <== NOT EXECUTED
  new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
a000f9ec:	e5813004 	str	r3, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
a000f9f0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000f9f4:	ebffff8f 	bl	a000f838 <_Heap_Free_block>                    <== NOT EXECUTED
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
a000f9f8:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
a000f9fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fa00:	0a00002b 	beq	a000fab4 <_Heap_Extend+0x25c>                 <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const last_block_new_size = _Heap_Align_down(             
    extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,      
a000fa04:	e2466008 	sub	r6, r6, #8                                    <== NOT EXECUTED
  uintptr_t extend_area_end                                           
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const last_block_new_size = _Heap_Align_down(             
a000fa08:	e0606006 	rsb	r6, r0, r6                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000fa0c:	e5951010 	ldr	r1, [r5, #16]                                 <== NOT EXECUTED
a000fa10:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000fa14:	eb00150f 	bl	a0014e58 <__umodsi3>                           <== NOT EXECUTED
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
    (last_block->size_and_flag - last_block_new_size)                 
a000fa18:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
a000fa1c:	e0606006 	rsb	r6, r0, r6                                    <== NOT EXECUTED
      | HEAP_PREV_BLOCK_USED;                                         
                                                                      
  _Heap_Block_set_size( last_block, last_block_new_size );            
                                                                      
  _Heap_Free_block( heap, last_block );                               
a000fa20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
    (last_block->size_and_flag - last_block_new_size)                 
a000fa24:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
a000fa28:	e0862001 	add	r2, r6, r1                                    <== NOT EXECUTED
    (last_block->size_and_flag - last_block_new_size)                 
a000fa2c:	e0663003 	rsb	r3, r6, r3                                    <== NOT EXECUTED
      | HEAP_PREV_BLOCK_USED;                                         
a000fa30:	e3833001 	orr	r3, r3, #1                                    <== NOT EXECUTED
    page_size                                                         
  );                                                                  
  Heap_Block *const new_last_block =                                  
    _Heap_Block_at( last_block, last_block_new_size );                
                                                                      
  new_last_block->size_and_flag =                                     
a000fa34:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a000fa38:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
a000fa3c:	e2033001 	and	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
  block->size_and_flag = size | flag;                                 
a000fa40:	e1866003 	orr	r6, r6, r3                                    <== NOT EXECUTED
a000fa44:	e5816004 	str	r6, [r1, #4]                                  <== NOT EXECUTED
    (last_block->size_and_flag - last_block_new_size)                 
      | HEAP_PREV_BLOCK_USED;                                         
                                                                      
  _Heap_Block_set_size( last_block, last_block_new_size );            
                                                                      
  _Heap_Free_block( heap, last_block );                               
a000fa48:	ebffff7a 	bl	a000f838 <_Heap_Free_block>                    <== NOT EXECUTED
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
a000fa4c:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
a000fa50:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
a000fa54:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000fa58:	03530000 	cmpeq	r3, #0                                      <== NOT EXECUTED
a000fa5c:	0a000021 	beq	a000fae8 <_Heap_Extend+0x290>                 <== NOT EXECUTED
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
}                                                                     
a000fa60:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
a000fa64:	e595c020 	ldr	ip, [r5, #32]                                 <== NOT EXECUTED
    _Heap_Free_block( heap, extend_first_block );                     
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
a000fa68:	e5952030 	ldr	r2, [r5, #48]	; 0x30                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a000fa6c:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
 * This feature will be used to terminate the scattered heap area list.  See
 * also _Heap_Extend().                                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{                                                                     
  _Heap_Block_set_size(                                               
a000fa70:	e063c00c 	rsb	ip, r3, ip                                    <== NOT EXECUTED
a000fa74:	e59d4018 	ldr	r4, [sp, #24]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a000fa78:	e2000001 	and	r0, r0, #1                                    <== NOT EXECUTED
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
a000fa7c:	e595102c 	ldr	r1, [r5, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
  block->size_and_flag = size | flag;                                 
a000fa80:	e18c0000 	orr	r0, ip, r0                                    <== NOT EXECUTED
                                                                      
  if ( extended_size_ptr != NULL )                                    
a000fa84:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
    _Heap_Free_block( heap, extend_first_block );                     
  }                                                                   
                                                                      
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
a000fa88:	e0642002 	rsb	r2, r4, r2                                    <== NOT EXECUTED
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
a000fa8c:	e0811002 	add	r1, r1, r2                                    <== NOT EXECUTED
                                                                      
  if ( extended_size_ptr != NULL )                                    
a000fa90:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000fa94:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
  _Heap_Set_last_block_size( heap );                                  
                                                                      
  extended_size = stats->free_size - free_size;                       
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
a000fa98:	e585102c 	str	r1, [r5, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
                                                                      
  return true;                                                        
a000fa9c:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
                                                                      
  if ( extended_size_ptr != NULL )                                    
    *extended_size_ptr = extended_size;                               
a000faa0:	158c2000 	strne	r2, [ip]                                    <== NOT EXECUTED
                                                                      
  return true;                                                        
a000faa4:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
a000faa8:	eaffff7b 	b	a000f89c <_Heap_Extend+0x44>                    <== NOT EXECUTED
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
      sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
    ) {                                                               
      return false;                                                   
a000faac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000fab0:	eaffff79 	b	a000f89c <_Heap_Extend+0x44>                    <== NOT EXECUTED
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
    _Heap_Merge_above( heap, merge_above_block, extend_area_end );    
  } else if ( link_above_block != NULL ) {                            
a000fab4:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a000fab8:	0affffe3 	beq	a000fa4c <_Heap_Extend+0x1f4>                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a000fabc:	e5971004 	ldr	r1, [r7, #4]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t const link_begin = (uintptr_t) link;                      
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
                                                                      
  _Heap_Block_set_size( link, first_block_begin - link_begin );       
a000fac0:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
    _Heap_Merge_above( heap, merge_above_block, extend_area_end );    
  } else if ( link_above_block != NULL ) {                            
    _Heap_Link_above(                                                 
a000fac4:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
a000fac8:	e2011001 	and	r1, r1, #1                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t const link_begin = (uintptr_t) link;                      
  uintptr_t const first_block_begin = (uintptr_t) first_block;        
                                                                      
  _Heap_Block_set_size( link, first_block_begin - link_begin );       
a000facc:	e0672002 	rsb	r2, r7, r2                                    <== NOT EXECUTED
                                                                      
  block->size_and_flag = size | flag;                                 
a000fad0:	e1822001 	orr	r2, r2, r1                                    <== NOT EXECUTED
a000fad4:	e5872004 	str	r2, [r7, #4]                                  <== NOT EXECUTED
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
a000fad8:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a000fadc:	e3822001 	orr	r2, r2, #1                                    <== NOT EXECUTED
a000fae0:	e5832004 	str	r2, [r3, #4]                                  <== NOT EXECUTED
a000fae4:	eaffffd8 	b	a000fa4c <_Heap_Extend+0x1f4>                   <== NOT EXECUTED
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
    _Heap_Free_block( heap, extend_first_block );                     
a000fae8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000faec:	e59d1020 	ldr	r1, [sp, #32]                                 <== NOT EXECUTED
a000faf0:	ebffff50 	bl	a000f838 <_Heap_Free_block>                    <== NOT EXECUTED
a000faf4:	eaffffd9 	b	a000fa60 <_Heap_Extend+0x208>                   <== NOT EXECUTED
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
    _Heap_Merge_below( heap, extend_area_begin, merge_below_block );  
  } else if ( link_below_block != NULL ) {                            
a000faf8:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
    (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;           
a000fafc:	1062b00b 	rsbne	fp, r2, fp                                  <== NOT EXECUTED
a000fb00:	138bb001 	orrne	fp, fp, #1                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t const last_block_begin = (uintptr_t) last_block;          
  uintptr_t const link_begin = (uintptr_t) link;                      
                                                                      
  last_block->size_and_flag =                                         
a000fb04:	1582b004 	strne	fp, [r2, #4]                                <== NOT EXECUTED
a000fb08:	eaffffba 	b	a000f9f8 <_Heap_Extend+0x1a0>                   <== NOT EXECUTED
                                                                      

a000f50c <_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 ) {
a000f50c:	e2513000 	subs	r3, r1, #0                                   
    return do_free;                                                   
  }                                                                   
#endif                                                                
                                                                      
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )          
{                                                                     
a000f510:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
a000f514:	e1a04000 	mov	r4, r0                                        
  /*                                                                  
   * 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 ) {                                    
a000f518:	0a000052 	beq	a000f668 <_Heap_Free+0x15c>                   
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000f51c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000f520:	e5941010 	ldr	r1, [r4, #16]                                 <== NOT EXECUTED
a000f524:	e2435008 	sub	r5, r3, #8                                    <== NOT EXECUTED
a000f528:	eb0014f5 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
a000f52c:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a000f530:	e0605005 	rsb	r5, r0, r5                                    <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000f534:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
a000f538:	3a000030 	bcc	a000f600 <_Heap_Free+0xf4>                    <== NOT EXECUTED
a000f53c:	e5941024 	ldr	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
a000f540:	e1550001 	cmp	r5, r1                                        <== NOT EXECUTED
a000f544:	8a00002d 	bhi	a000f600 <_Heap_Free+0xf4>                    <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f548:	e595c004 	ldr	ip, [r5, #4]                                  <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000f54c:	e3cc6001 	bic	r6, ip, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000f550:	e0853006 	add	r3, r5, r6                                    <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000f554:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000f558:	8a000028 	bhi	a000f600 <_Heap_Free+0xf4>                    <== NOT EXECUTED
a000f55c:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
    return false;                                                     
a000f560:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
a000f564:	3a000027 	bcc	a000f608 <_Heap_Free+0xfc>                    <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f568:	e5937004 	ldr	r7, [r3, #4]                                  <== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
a000f56c:	e2170001 	ands	r0, r7, #1                                   <== NOT EXECUTED
a000f570:	0a000024 	beq	a000f608 <_Heap_Free+0xfc>                    <== NOT EXECUTED
    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 ));
a000f574:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000f578:	e3c77001 	bic	r7, r7, #1                                    <== NOT EXECUTED
a000f57c:	03a08000 	moveq	r8, #0                                      <== NOT EXECUTED
a000f580:	0a000004 	beq	a000f598 <_Heap_Free+0x8c>                    <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f584:	e0830007 	add	r0, r3, r7                                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000f588:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
                                                                      
    return do_free;                                                   
  }                                                                   
#endif                                                                
                                                                      
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )          
a000f58c:	e3100001 	tst	r0, #1                                        <== NOT EXECUTED
a000f590:	13a08000 	movne	r8, #0                                      <== NOT EXECUTED
a000f594:	03a08001 	moveq	r8, #1                                      <== NOT EXECUTED
                                                                      
  next_block_size = _Heap_Block_size( next_block );                   
  next_is_free = next_block != heap->last_block                       
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
a000f598:	e21c0001 	ands	r0, ip, #1                                   <== NOT EXECUTED
a000f59c:	1a00001a 	bne	a000f60c <_Heap_Free+0x100>                   <== NOT EXECUTED
    uintptr_t const prev_size = block->prev_size;                     
a000f5a0:	e595c000 	ldr	ip, [r5]                                      <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000f5a4:	e06ca005 	rsb	sl, ip, r5                                    <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000f5a8:	e152000a 	cmp	r2, sl                                        <== NOT EXECUTED
a000f5ac:	8a000015 	bhi	a000f608 <_Heap_Free+0xfc>                    <== NOT EXECUTED
a000f5b0:	e151000a 	cmp	r1, sl                                        <== NOT EXECUTED
a000f5b4:	3a000013 	bcc	a000f608 <_Heap_Free+0xfc>                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000f5b8:	e59a0004 	ldr	r0, [sl, #4]                                  <== NOT EXECUTED
      return( false );                                                
    }                                                                 
                                                                      
    /* As we always coalesce free blocks, the block that preceedes prev_block
       must have been used. */                                        
    if ( !_Heap_Is_prev_used ( prev_block) ) {                        
a000f5bc:	e2100001 	ands	r0, r0, #1                                   <== NOT EXECUTED
a000f5c0:	0a000010 	beq	a000f608 <_Heap_Free+0xfc>                    <== NOT EXECUTED
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
a000f5c4:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000f5c8:	0a00003a 	beq	a000f6b8 <_Heap_Free+0x1ac>                   <== NOT EXECUTED
      uintptr_t const size = block_size + prev_size + next_block_size;
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
a000f5cc:	e5940038 	ldr	r0, [r4, #56]	; 0x38                          <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f5d0:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
a000f5d4:	e0867007 	add	r7, r6, r7                                    <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f5d8:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
a000f5dc:	e087c00c 	add	ip, r7, ip                                    <== NOT EXECUTED
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
a000f5e0:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
a000f5e4:	e38c1001 	orr	r1, ip, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
  Heap_Block *prev = block->prev;                                     
                                                                      
  prev->next = next;                                                  
a000f5e8:	e5832008 	str	r2, [r3, #8]                                  <== NOT EXECUTED
  next->prev = prev;                                                  
a000f5ec:	e582300c 	str	r3, [r2, #12]                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
a000f5f0:	e5840038 	str	r0, [r4, #56]	; 0x38                          <== NOT EXECUTED
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
a000f5f4:	e58a1004 	str	r1, [sl, #4]                                  <== NOT EXECUTED
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
a000f5f8:	e78ac00c 	str	ip, [sl, ip]                                  <== NOT EXECUTED
a000f5fc:	ea00000e 	b	a000f63c <_Heap_Free+0x130>                     <== NOT EXECUTED
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
    return false;                                                     
a000f600:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000f604:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f608:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
a000f60c:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000f610:	0a000016 	beq	a000f670 <_Heap_Free+0x164>                   <== NOT EXECUTED
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
a000f614:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
a000f618:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
      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;              
a000f61c:	e0877006 	add	r7, r7, r6                                    <== NOT EXECUTED
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
a000f620:	e3871001 	orr	r1, r7, #1                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
a000f624:	e5852008 	str	r2, [r5, #8]                                  <== NOT EXECUTED
  new_block->prev = prev;                                             
a000f628:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
                                                                      
  next->prev = new_block;                                             
  prev->next = new_block;                                             
a000f62c:	e5835008 	str	r5, [r3, #8]                                  <== NOT EXECUTED
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
  new_block->prev = prev;                                             
                                                                      
  next->prev = new_block;                                             
a000f630:	e582500c 	str	r5, [r2, #12]                                 <== NOT EXECUTED
a000f634:	e5851004 	str	r1, [r5, #4]                                  <== NOT EXECUTED
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
a000f638:	e7857007 	str	r7, [r5, r7]                                  <== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
a000f63c:	e5942040 	ldr	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
  ++stats->frees;                                                     
a000f640:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
  stats->free_size += block_size;                                     
a000f644:	e5941030 	ldr	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
a000f648:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
  ++stats->frees;                                                     
a000f64c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
  stats->free_size += block_size;                                     
a000f650:	e0816006 	add	r6, r1, r6                                    <== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
a000f654:	e5842040 	str	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
  ++stats->frees;                                                     
a000f658:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
  stats->free_size += block_size;                                     
a000f65c:	e5846030 	str	r6, [r4, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
  return( true );                                                     
a000f660:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000f664:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
   * 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 ) {                                    
    return true;                                                      
a000f668:	e3a00001 	mov	r0, #1                                        
a000f66c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
    next_block->prev_size = size;                                     
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
a000f670:	e3862001 	orr	r2, r6, #1                                    <== NOT EXECUTED
a000f674:	e5852004 	str	r2, [r5, #4]                                  <== NOT EXECUTED
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
a000f678:	e5942038 	ldr	r2, [r4, #56]	; 0x38                          <== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks ) {              
a000f67c:	e594c03c 	ldr	ip, [r4, #60]	; 0x3c                          <== NOT EXECUTED
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
a000f680:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(               
  Heap_Block *block_before,                                           
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
a000f684:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
a000f688:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
a000f68c:	e3c00001 	bic	r0, r0, #1                                    <== NOT EXECUTED
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
    if ( stats->max_free_blocks < stats->free_blocks ) {              
a000f690:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
                                                                      
  new_block->next = next;                                             
a000f694:	e5851008 	str	r1, [r5, #8]                                  <== NOT EXECUTED
  new_block->prev = block_before;                                     
a000f698:	e585400c 	str	r4, [r5, #12]                                 <== NOT EXECUTED
  } else {                        /* no coalesce */                   
    /* Add 'block' to the head of the free blocks list as it tends to 
       produce less fragmentation than adding to the tail. */         
    _Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
    block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;         
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
a000f69c:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
a000f6a0:	e581500c 	str	r5, [r1, #12]                                 <== NOT EXECUTED
    next_block->prev_size = block_size;                               
a000f6a4:	e7856006 	str	r6, [r5, r6]                                  <== NOT EXECUTED
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
a000f6a8:	e5845008 	str	r5, [r4, #8]                                  <== NOT EXECUTED
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
a000f6ac:	e5842038 	str	r2, [r4, #56]	; 0x38                          <== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks ) {              
      stats->max_free_blocks = stats->free_blocks;                    
a000f6b0:	8584203c 	strhi	r2, [r4, #60]	; 0x3c                        <== NOT EXECUTED
a000f6b4:	eaffffe0 	b	a000f63c <_Heap_Free+0x130>                     <== NOT EXECUTED
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
a000f6b8:	e086c00c 	add	ip, r6, ip                                    <== NOT EXECUTED
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
a000f6bc:	e38c2001 	orr	r2, ip, #1                                    <== NOT EXECUTED
a000f6c0:	e58a2004 	str	r2, [sl, #4]                                  <== NOT EXECUTED
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
a000f6c4:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
      next_block->prev_size = size;                                   
a000f6c8:	e785c006 	str	ip, [r5, r6]                                  <== NOT EXECUTED
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
    } else {                      /* coalesce prev */                 
      uintptr_t const size = block_size + prev_size;                  
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
a000f6cc:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
a000f6d0:	e5832004 	str	r2, [r3, #4]                                  <== NOT EXECUTED
a000f6d4:	eaffffd8 	b	a000f63c <_Heap_Free+0x130>                     <== NOT EXECUTED
                                                                      

a000f838 <_Heap_Free_block>: static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) { Heap_Statistics *const stats = &heap->stats; /* Statistics */ ++stats->used_blocks;
a000f838:	e590c040 	ldr	ip, [r0, #64]	; 0x40                          <== NOT EXECUTED
  --stats->frees;                                                     
a000f83c:	e5902050 	ldr	r2, [r0, #80]	; 0x50                          <== NOT EXECUTED
                                                                      
  _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));     
a000f840:	e2811008 	add	r1, r1, #8                                    <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) 
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  /* Statistics */                                                    
  ++stats->used_blocks;                                               
a000f844:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
  --stats->frees;                                                     
a000f848:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block ) 
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  /* Statistics */                                                    
  ++stats->used_blocks;                                               
a000f84c:	e580c040 	str	ip, [r0, #64]	; 0x40                          <== NOT EXECUTED
  --stats->frees;                                                     
a000f850:	e5802050 	str	r2, [r0, #80]	; 0x50                          <== NOT EXECUTED
                                                                      
  _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));     
a000f854:	ea0000ac 	b	a000fb0c <_Heap_Free>                           <== NOT EXECUTED
                                                                      

a000aa54 <_Heap_Get_first_and_last_block>: uintptr_t page_size, uintptr_t min_block_size, Heap_Block **first_block_ptr, Heap_Block **last_block_ptr ) {
a000aa54:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  uintptr_t const heap_area_end = heap_area_begin + heap_area_size;   
  uintptr_t const alloc_area_begin =                                  
    _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
a000aa58:	e2807008 	add	r7, r0, #8                                    
  uintptr_t page_size,                                                
  uintptr_t min_block_size,                                           
  Heap_Block **first_block_ptr,                                       
  Heap_Block **last_block_ptr                                         
)                                                                     
{                                                                     
a000aa5c:	e1a04000 	mov	r4, r0                                        
a000aa60:	e1a05001 	mov	r5, r1                                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(                        
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  uintptr_t remainder = value % alignment;                            
a000aa64:	e1a00007 	mov	r0, r7                                        
a000aa68:	e1a01002 	mov	r1, r2                                        
a000aa6c:	e1a06002 	mov	r6, r2                                        
a000aa70:	e1a08003 	mov	r8, r3                                        
a000aa74:	eb0027a2 	bl	a0014904 <__umodsi3>                           
                                                                      
  if ( remainder != 0 ) {                                             
a000aa78:	e3500000 	cmp	r0, #0                                        
    return value - remainder + alignment;                             
a000aa7c:	10867007 	addne	r7, r6, r7                                  
a000aa80:	10607007 	rsbne	r7, r0, r7                                  
  uintptr_t const heap_area_end = heap_area_begin + heap_area_size;   
  uintptr_t const alloc_area_begin =                                  
    _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const first_block_begin =                                 
    alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;                        
  uintptr_t const overhead =                                          
a000aa84:	e0643007 	rsb	r3, r4, r7                                    
  uintptr_t min_block_size,                                           
  Heap_Block **first_block_ptr,                                       
  Heap_Block **last_block_ptr                                         
)                                                                     
{                                                                     
  uintptr_t const heap_area_end = heap_area_begin + heap_area_size;   
a000aa88:	e0852004 	add	r2, r5, r4                                    
    _Heap_Align_down( heap_area_size - overhead, page_size );         
  Heap_Block *const first_block = (Heap_Block *) first_block_begin;   
  Heap_Block *const last_block =                                      
    _Heap_Block_at( first_block, first_block_size );                  
                                                                      
  if (                                                                
a000aa8c:	e1520004 	cmp	r2, r4                                        
a000aa90:	21550003 	cmpcs	r5, r3                                      
a000aa94:	83a04000 	movhi	r4, #0                                      
a000aa98:	93a04001 	movls	r4, #1                                      
  uintptr_t const alloc_area_begin =                                  
    _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
  uintptr_t const first_block_begin =                                 
    alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;                        
  uintptr_t const overhead =                                          
    HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);   
a000aa9c:	e2477008 	sub	r7, r7, #8                                    
    _Heap_Align_down( heap_area_size - overhead, page_size );         
  Heap_Block *const first_block = (Heap_Block *) first_block_begin;   
  Heap_Block *const last_block =                                      
    _Heap_Block_at( first_block, first_block_size );                  
                                                                      
  if (                                                                
a000aaa0:	9a00000f 	bls	a000aae4 <_Heap_Get_first_and_last_block+0x90>
  uintptr_t const first_block_begin =                                 
    alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;                        
  uintptr_t const overhead =                                          
    HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);   
  uintptr_t const first_block_size =                                  
    _Heap_Align_down( heap_area_size - overhead, page_size );         
a000aaa4:	e0635005 	rsb	r5, r3, r5                                    
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a000aaa8:	e1a00005 	mov	r0, r5                                        
a000aaac:	e1a01006 	mov	r1, r6                                        
a000aab0:	eb002793 	bl	a0014904 <__umodsi3>                           
a000aab4:	e0605005 	rsb	r5, r0, r5                                    
    _Heap_Block_at( first_block, first_block_size );                  
                                                                      
  if (                                                                
    heap_area_end < heap_area_begin                                   
      || heap_area_size <= overhead                                   
      || first_block_size < min_block_size                            
a000aab8:	e1580005 	cmp	r8, r5                                        
a000aabc:	8a000006 	bhi	a000aadc <_Heap_Get_first_and_last_block+0x88>
  ) {                                                                 
    /* Invalid area or area too small */                              
    return false;                                                     
  }                                                                   
                                                                      
  *first_block_ptr = first_block;                                     
a000aac0:	e59d3018 	ldr	r3, [sp, #24]                                 
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000aac4:	e0855007 	add	r5, r5, r7                                    
  *last_block_ptr = last_block;                                       
                                                                      
  return true;                                                        
a000aac8:	e3a00001 	mov	r0, #1                                        
  ) {                                                                 
    /* Invalid area or area too small */                              
    return false;                                                     
  }                                                                   
                                                                      
  *first_block_ptr = first_block;                                     
a000aacc:	e5837000 	str	r7, [r3]                                      
  *last_block_ptr = last_block;                                       
a000aad0:	e59d301c 	ldr	r3, [sp, #28]                                 
a000aad4:	e5835000 	str	r5, [r3]                                      
                                                                      
  return true;                                                        
a000aad8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
    heap_area_end < heap_area_begin                                   
      || heap_area_size <= overhead                                   
      || first_block_size < min_block_size                            
  ) {                                                                 
    /* Invalid area or area too small */                              
    return false;                                                     
a000aadc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  *first_block_ptr = first_block;                                     
  *last_block_ptr = last_block;                                       
                                                                      
  return true;                                                        
}                                                                     
a000aae0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    heap_area_end < heap_area_begin                                   
      || heap_area_size <= overhead                                   
      || first_block_size < min_block_size                            
  ) {                                                                 
    /* Invalid area or area too small */                              
    return false;                                                     
a000aae4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000aae8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a0014d28 <_Heap_Get_free_information>: info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } }
a0014d28:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Heap_Block *the_block;                                              
  Heap_Block *const tail = _Heap_Free_list_tail(the_heap);            
                                                                      
  info->number = 0;                                                   
a0014d2c:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
                                                                      
void _Heap_Get_free_information(                                      
  Heap_Control        *the_heap,                                      
  Heap_Information    *info                                           
)                                                                     
{                                                                     
a0014d30:	e92d0070 	push	{r4, r5, r6}                                 <== NOT EXECUTED
                                                                      
  info->number = 0;                                                   
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
a0014d34:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Heap_Block *the_block;                                              
  Heap_Block *const tail = _Heap_Free_list_tail(the_heap);            
                                                                      
  info->number = 0;                                                   
a0014d38:	e581c000 	str	ip, [r1]                                      <== NOT EXECUTED
  info->largest = 0;                                                  
a0014d3c:	e581c004 	str	ip, [r1, #4]                                  <== NOT EXECUTED
  info->total = 0;                                                    
a0014d40:	e581c008 	str	ip, [r1, #8]                                  <== NOT EXECUTED
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
a0014d44:	0a00000f 	beq	a0014d88 <_Heap_Get_free_information+0x60>    <== NOT EXECUTED
a0014d48:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
a0014d4c:	e1a0400c 	mov	r4, ip                                        <== NOT EXECUTED
a0014d50:	ea000001 	b	a0014d5c <_Heap_Get_free_information+0x34>      <== NOT EXECUTED
a0014d54:	e591c004 	ldr	ip, [r1, #4]                                  <== NOT EXECUTED
a0014d58:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a0014d5c:	e993000c 	ldmib	r3, {r2, r3}                                <== NOT EXECUTED
      the_block != tail;                                              
      the_block = the_block->next)                                    
a0014d60:	e2856001 	add	r6, r5, #1                                    <== NOT EXECUTED
a0014d64:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
    /* 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 )                                   
a0014d68:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
        info->largest = the_size;                                     
a0014d6c:	85812004 	strhi	r2, [r1, #4]                                <== NOT EXECUTED
                                                                      
    /* 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;                                          
a0014d70:	e084c002 	add	ip, r4, r2                                    <== NOT EXECUTED
                                                                      
  info->number = 0;                                                   
  info->largest = 0;                                                  
  info->total = 0;                                                    
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
a0014d74:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0014d78:	e1a0400c 	mov	r4, ip                                        <== NOT EXECUTED
a0014d7c:	1afffff4 	bne	a0014d54 <_Heap_Get_free_information+0x2c>    <== NOT EXECUTED
a0014d80:	e5815000 	str	r5, [r1]                                      <== NOT EXECUTED
a0014d84:	e581c008 	str	ip, [r1, #8]                                  <== NOT EXECUTED
    info->number++;                                                   
    info->total += the_size;                                          
    if ( info->largest < the_size )                                   
        info->largest = the_size;                                     
  }                                                                   
}                                                                     
a0014d88:	e8bd0070 	pop	{r4, r5, r6}                                  <== NOT EXECUTED
a0014d8c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a001018c <_Heap_Get_information>: ) { Heap_Block *the_block = the_heap->first_block; Heap_Block *const end = the_heap->last_block; memset(the_info, 0, sizeof(*the_info));
a001018c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010190:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
void _Heap_Get_information(                                           
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
)                                                                     
{                                                                     
  Heap_Block *the_block = the_heap->first_block;                      
a0010194:	e590c020 	ldr	ip, [r0, #32]                                 <== NOT EXECUTED
                                                                      
void _Heap_Get_information(                                           
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
)                                                                     
{                                                                     
a0010198:	e92d00f0 	push	{r4, r5, r6, r7}                             <== NOT EXECUTED
  Heap_Block *the_block = the_heap->first_block;                      
  Heap_Block *const end = the_heap->last_block;                       
a001019c:	e5907024 	ldr	r7, [r0, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
a00101a0:	e4823004 	str	r3, [r2], #4                                  <== NOT EXECUTED
a00101a4:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
a00101a8:	e5813004 	str	r3, [r1, #4]                                  <== NOT EXECUTED
a00101ac:	e4823004 	str	r3, [r2], #4                                  <== NOT EXECUTED
a00101b0:	e4823004 	str	r3, [r2], #4                                  <== NOT EXECUTED
a00101b4:	e4823004 	str	r3, [r2], #4                                  <== NOT EXECUTED
                                                                      
  while ( the_block != end ) {                                        
a00101b8:	e15c0007 	cmp	ip, r7                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Heap_Block *the_block = the_heap->first_block;                      
  Heap_Block *const end = the_heap->last_block;                       
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
a00101bc:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  while ( the_block != end ) {                                        
a00101c0:	0a000010 	beq	a0010208 <_Heap_Get_information+0x7c>         <== NOT EXECUTED
a00101c4:	e59c0004 	ldr	r0, [ip, #4]                                  <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a00101c8:	e3c02001 	bic	r2, r0, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a00101cc:	e08cc002 	add	ip, ip, r2                                    <== NOT EXECUTED
    if ( info->largest < the_size )                                   
      info->largest = the_size;                                       
                                                                      
    the_block = next_block;                                           
  }                                                                   
}                                                                     
a00101d0:	e59c0004 	ldr	r0, [ip, #4]                                  <== NOT EXECUTED
    Heap_Information  *info;                                          
                                                                      
    if ( _Heap_Is_prev_used(next_block) )                             
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
a00101d4:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  while ( the_block != end ) {                                        
    uintptr_t const     the_size = _Heap_Block_size(the_block);       
    Heap_Block *const  next_block = _Heap_Block_at(the_block, the_size);
    Heap_Information  *info;                                          
                                                                      
    if ( _Heap_Is_prev_used(next_block) )                             
a00101d8:	e3100001 	tst	r0, #1                                        <== NOT EXECUTED
      info = &the_info->Used;                                         
a00101dc:	1281300c 	addne	r3, r1, #12                                 <== NOT EXECUTED
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
    info->total += the_size;                                          
    if ( info->largest < the_size )                                   
a00101e0:	e8930060 	ldm	r3, {r5, r6}                                  <== NOT EXECUTED
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
    info->total += the_size;                                          
a00101e4:	e5934008 	ldr	r4, [r3, #8]                                  <== NOT EXECUTED
    if ( info->largest < the_size )                                   
a00101e8:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
    if ( _Heap_Is_prev_used(next_block) )                             
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
a00101ec:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    info->total += the_size;                                          
a00101f0:	e0844002 	add	r4, r4, r2                                    <== NOT EXECUTED
    if ( info->largest < the_size )                                   
      info->largest = the_size;                                       
a00101f4:	35832004 	strcc	r2, [r3, #4]                                <== NOT EXECUTED
  Heap_Block *the_block = the_heap->first_block;                      
  Heap_Block *const end = the_heap->last_block;                       
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
                                                                      
  while ( the_block != end ) {                                        
a00101f8:	e157000c 	cmp	r7, ip                                        <== NOT EXECUTED
    if ( _Heap_Is_prev_used(next_block) )                             
      info = &the_info->Used;                                         
    else                                                              
      info = &the_info->Free;                                         
                                                                      
    info->number++;                                                   
a00101fc:	e5835000 	str	r5, [r3]                                      <== NOT EXECUTED
    info->total += the_size;                                          
a0010200:	e5834008 	str	r4, [r3, #8]                                  <== NOT EXECUTED
  Heap_Block *the_block = the_heap->first_block;                      
  Heap_Block *const end = the_heap->last_block;                       
                                                                      
  memset(the_info, 0, sizeof(*the_info));                             
                                                                      
  while ( the_block != end ) {                                        
a0010204:	1affffef 	bne	a00101c8 <_Heap_Get_information+0x3c>         <== NOT EXECUTED
    if ( info->largest < the_size )                                   
      info->largest = the_size;                                       
                                                                      
    the_block = next_block;                                           
  }                                                                   
}                                                                     
a0010208:	e8bd00f0 	pop	{r4, r5, r6, r7}                              <== NOT EXECUTED
a001020c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0016480 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) {
a0016480:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a0016484:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0016488:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a001648c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0016490:	e5941010 	ldr	r1, [r4, #16]                                 <== NOT EXECUTED
a0016494:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
a0016498:	e1a0a002 	mov	sl, r2                                        <== NOT EXECUTED
a001649c:	ebfff918 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a00164a0:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a00164a4:	e59d601c 	ldr	r6, [sp, #28]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a00164a8:	e2458008 	sub	r8, r5, #8                                    <== NOT EXECUTED
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a00164ac:	e0601008 	rsb	r1, r0, r8                                    <== NOT EXECUTED
                                                                      
  uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;          
                                                                      
  Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
                                                                      
  *old_size = 0;                                                      
a00164b0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a00164b4:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a00164b8:	e5872000 	str	r2, [r7]                                      <== NOT EXECUTED
  *new_size = 0;                                                      
a00164bc:	e5862000 	str	r2, [r6]                                      <== NOT EXECUTED
a00164c0:	8a000038 	bhi	a00165a8 <_Heap_Resize_block+0x128>           <== NOT EXECUTED
a00164c4:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
a00164c8:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a00164cc:	3a000037 	bcc	a00165b0 <_Heap_Resize_block+0x130>           <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a00164d0:	e5910004 	ldr	r0, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t block_size = _Heap_Block_size( block );                   
  uintptr_t block_end = block_begin + block_size;                     
                                                                      
  uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;  
a00164d4:	e2653004 	rsb	r3, r5, #4                                    <== NOT EXECUTED
a00164d8:	e3c00001 	bic	r0, r0, #1                                    <== NOT EXECUTED
{                                                                     
  Heap_Statistics *const stats = &heap->stats;                        
                                                                      
  uintptr_t const block_begin = (uintptr_t) block;                    
  uintptr_t block_size = _Heap_Block_size( block );                   
  uintptr_t block_end = block_begin + block_size;                     
a00164dc:	e0812000 	add	r2, r1, r0                                    <== NOT EXECUTED
a00164e0:	e592c004 	ldr	ip, [r2, #4]                                  <== NOT EXECUTED
                                                                      
  uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;  
a00164e4:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
a00164e8:	e3ccc001 	bic	ip, ip, #1                                    <== NOT EXECUTED
      old_size,                                                       
      new_size                                                        
    );                                                                
  }                                                                   
  return HEAP_RESIZE_FATAL_ERROR;                                     
}                                                                     
a00164ec:	e082800c 	add	r8, r2, ip                                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a00164f0:	e5988004 	ldr	r8, [r8, #4]                                  <== NOT EXECUTED
  bool next_block_is_free = _Heap_Is_free( next_block );;             
                                                                      
  _HAssert( _Heap_Is_block_in_heap( heap, next_block ) );             
  _HAssert( _Heap_Is_prev_used( next_block ) );                       
                                                                      
  *old_size = alloc_size;                                             
a00164f4:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(                              
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return !_Heap_Is_used( block );                                     
a00164f8:	e3180001 	tst	r8, #1                                        <== NOT EXECUTED
a00164fc:	13a07000 	movne	r7, #0                                      <== NOT EXECUTED
a0016500:	03a07001 	moveq	r7, #1                                      <== NOT EXECUTED
                                                                      
  if ( next_block_is_free ) {                                         
a0016504:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    block_size += next_block_size;                                    
    alloc_size += next_block_size;                                    
a0016508:	1083300c 	addne	r3, r3, ip                                  <== NOT EXECUTED
  _HAssert( _Heap_Is_prev_used( next_block ) );                       
                                                                      
  *old_size = alloc_size;                                             
                                                                      
  if ( next_block_is_free ) {                                         
    block_size += next_block_size;                                    
a001650c:	1080000c 	addne	r0, r0, ip                                  <== NOT EXECUTED
    alloc_size += next_block_size;                                    
  }                                                                   
                                                                      
  if ( new_alloc_size > alloc_size ) {                                
a0016510:	e15a0003 	cmp	sl, r3                                        <== NOT EXECUTED
a0016514:	8a000027 	bhi	a00165b8 <_Heap_Resize_block+0x138>           <== NOT EXECUTED
    return HEAP_RESIZE_UNSATISFIED;                                   
  }                                                                   
                                                                      
  if ( next_block_is_free ) {                                         
a0016518:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a001651c:	0a000011 	beq	a0016568 <_Heap_Resize_block+0xe8>            <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a0016520:	e5917004 	ldr	r7, [r1, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a0016524:	e0803001 	add	r3, r0, r1                                    <== NOT EXECUTED
                                                                      
    next_block = _Heap_Block_at( block, block_size );                 
    next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a0016528:	e594e038 	ldr	lr, [r4, #56]	; 0x38                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(                       
  Heap_Block *block,                                                  
  uintptr_t size                                                      
)                                                                     
{                                                                     
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;       
a001652c:	e2077001 	and	r7, r7, #1                                    <== NOT EXECUTED
                                                                      
  block->size_and_flag = size | flag;                                 
a0016530:	e1800007 	orr	r0, r0, r7                                    <== NOT EXECUTED
a0016534:	e5810004 	str	r0, [r1, #4]                                  <== NOT EXECUTED
    stats->free_size -= next_block_size;                              
a0016538:	e5948030 	ldr	r8, [r4, #48]	; 0x30                          <== NOT EXECUTED
    _Heap_Block_set_size( block, block_size );                        
                                                                      
    _Heap_Free_list_remove( next_block );                             
                                                                      
    next_block = _Heap_Block_at( block, block_size );                 
    next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                
a001653c:	e5937004 	ldr	r7, [r3, #4]                                  <== NOT EXECUTED
      old_size,                                                       
      new_size                                                        
    );                                                                
  }                                                                   
  return HEAP_RESIZE_FATAL_ERROR;                                     
}                                                                     
a0016540:	e5920008 	ldr	r0, [r2, #8]                                  <== NOT EXECUTED
a0016544:	e592200c 	ldr	r2, [r2, #12]                                 <== NOT EXECUTED
    _Heap_Block_set_size( block, block_size );                        
                                                                      
    _Heap_Free_list_remove( next_block );                             
                                                                      
    next_block = _Heap_Block_at( block, block_size );                 
    next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                
a0016548:	e3877001 	orr	r7, r7, #1                                    <== NOT EXECUTED
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a001654c:	e24ee001 	sub	lr, lr, #1                                    <== NOT EXECUTED
    stats->free_size -= next_block_size;                              
a0016550:	e06cc008 	rsb	ip, ip, r8                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
  Heap_Block *prev = block->prev;                                     
                                                                      
  prev->next = next;                                                  
a0016554:	e5820008 	str	r0, [r2, #8]                                  <== NOT EXECUTED
  next->prev = prev;                                                  
a0016558:	e580200c 	str	r2, [r0, #12]                                 <== NOT EXECUTED
    _Heap_Block_set_size( block, block_size );                        
                                                                      
    _Heap_Free_list_remove( next_block );                             
                                                                      
    next_block = _Heap_Block_at( block, block_size );                 
    next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                
a001655c:	e5837004 	str	r7, [r3, #4]                                  <== NOT EXECUTED
                                                                      
    /* Statistics */                                                  
    --stats->free_blocks;                                             
a0016560:	e584e038 	str	lr, [r4, #56]	; 0x38                          <== NOT EXECUTED
    stats->free_size -= next_block_size;                              
a0016564:	e584c030 	str	ip, [r4, #48]	; 0x30                          <== NOT EXECUTED
  }                                                                   
                                                                      
  block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
a0016568:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a001656c:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
a0016570:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0016574:	ebffd1a6 	bl	a000ac14 <_Heap_Block_allocate>                <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a0016578:	e5902004 	ldr	r2, [r0, #4]                                  <== NOT EXECUTED
a001657c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
                                                                      
  /* Statistics */                                                    
  ++stats->resizes;                                                   
                                                                      
  return HEAP_RESIZE_SUCCESSFUL;                                      
a0016580:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0016584:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a0016588:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
                                                                      
  block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
  *new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
a001658c:	e0655002 	rsb	r5, r5, r2                                    <== NOT EXECUTED
a0016590:	e0833005 	add	r3, r3, r5                                    <== NOT EXECUTED
a0016594:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
  /* Statistics */                                                    
  ++stats->resizes;                                                   
a0016598:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          <== NOT EXECUTED
a001659c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a00165a0:	e5843054 	str	r3, [r4, #84]	; 0x54                          <== NOT EXECUTED
a00165a4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
      new_alloc_size,                                                 
      old_size,                                                       
      new_size                                                        
    );                                                                
  }                                                                   
  return HEAP_RESIZE_FATAL_ERROR;                                     
a00165a8:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
a00165ac:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
a00165b0:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
}                                                                     
a00165b4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    block_size += next_block_size;                                    
    alloc_size += next_block_size;                                    
  }                                                                   
                                                                      
  if ( new_alloc_size > alloc_size ) {                                
    return HEAP_RESIZE_UNSATISFIED;                                   
a00165b8:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
  *old_size = 0;                                                      
  *new_size = 0;                                                      
                                                                      
  if ( _Heap_Is_block_in_heap( heap, block ) ) {                      
    _Heap_Protection_block_check( heap, block );                      
    return _Heap_Resize_block_checked(                                
a00165bc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a00165c0 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) {
a00165c0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
a00165c4:	e1a04000 	mov	r4, r0                                        
a00165c8:	e1a05001 	mov	r5, r1                                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a00165cc:	e1a00001 	mov	r0, r1                                        
a00165d0:	e5941010 	ldr	r1, [r4, #16]                                 
a00165d4:	e1a07002 	mov	r7, r2                                        
a00165d8:	ebfff8c9 	bl	a0014904 <__umodsi3>                           
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(                     
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
a00165dc:	e5943020 	ldr	r3, [r4, #32]                                 
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
a00165e0:	e2456008 	sub	r6, r5, #8                                    
  uintptr_t alloc_begin,                                              
  uintptr_t page_size                                                 
)                                                                     
{                                                                     
  return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )   
    - HEAP_BLOCK_HEADER_SIZE);                                        
a00165e4:	e0600006 	rsb	r0, r0, r6                                    
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a00165e8:	e1500003 	cmp	r0, r3                                        
a00165ec:	3a000012 	bcc	a001663c <_Heap_Size_of_alloc_area+0x7c>      
a00165f0:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          
a00165f4:	e1500002 	cmp	r0, r2                                        
a00165f8:	8a00000f 	bhi	a001663c <_Heap_Size_of_alloc_area+0x7c>      
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a00165fc:	e5906004 	ldr	r6, [r0, #4]                                  
a0016600:	e3c66001 	bic	r6, r6, #1                                    
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a0016604:	e0806006 	add	r6, r0, r6                                    
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a0016608:	e1530006 	cmp	r3, r6                                        
a001660c:	8a00000a 	bhi	a001663c <_Heap_Size_of_alloc_area+0x7c>      
a0016610:	e1520006 	cmp	r2, r6                                        
                                                                      
  if (                                                                
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
a0016614:	33a00000 	movcc	r0, #0                                      
a0016618:	3a000009 	bcc	a0016644 <_Heap_Size_of_alloc_area+0x84>      
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a001661c:	e5960004 	ldr	r0, [r6, #4]                                  
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
a0016620:	e2100001 	ands	r0, r0, #1                                   
a0016624:	0a000006 	beq	a0016644 <_Heap_Size_of_alloc_area+0x84>      
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
a0016628:	e2655004 	rsb	r5, r5, #4                                    
a001662c:	e0856006 	add	r6, r5, r6                                    
a0016630:	e5876000 	str	r6, [r7]                                      
                                                                      
  return true;                                                        
a0016634:	e3a00001 	mov	r0, #1                                        
a0016638:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      
  if (                                                                
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
a001663c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0016640:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
}                                                                     
a0016644:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000b9b4 <_Heap_Walk>: Heap_Block *const last_block = heap->last_block; Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; if ( !_System_state_Is_up( _System_state_Get() ) ) {
a000b9b4:	e59f3584 	ldr	r3, [pc, #1412]	; a000bf40 <_Heap_Walk+0x58c> <== NOT EXECUTED
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
a000b9b8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  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;                      
a000b9bc:	e31200ff 	tst	r2, #255	; 0xff                               <== NOT EXECUTED
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
a000b9c0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
  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;                      
a000b9c4:	e59f2578 	ldr	r2, [pc, #1400]	; a000bf44 <_Heap_Walk+0x590> <== NOT EXECUTED
a000b9c8:	e59f9578 	ldr	r9, [pc, #1400]	; a000bf48 <_Heap_Walk+0x594> <== NOT EXECUTED
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
a000b9cc:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
  uintptr_t const page_size = heap->page_size;                        
a000b9d0:	e5901010 	ldr	r1, [r0, #16]                                 <== NOT EXECUTED
  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;                      
a000b9d4:	11a09002 	movne	r9, r2                                      <== NOT EXECUTED
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
a000b9d8:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
  uintptr_t const min_block_size = heap->min_block_size;              
a000b9dc:	e5902014 	ldr	r2, [r0, #20]                                 <== NOT EXECUTED
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
a000b9e0:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          <== NOT EXECUTED
bool _Heap_Walk(                                                      
  Heap_Control *heap,                                                 
  int source,                                                         
  bool dump                                                           
)                                                                     
{                                                                     
a000b9e4:	e24dd038 	sub	sp, sp, #56	; 0x38                            <== NOT EXECUTED
a000b9e8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  uintptr_t const page_size = heap->page_size;                        
a000b9ec:	e58d1024 	str	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
  uintptr_t const min_block_size = heap->min_block_size;              
a000b9f0:	e58d2028 	str	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
  Heap_Block *const first_block = heap->first_block;                  
a000b9f4:	e5908020 	ldr	r8, [r0, #32]                                 <== NOT EXECUTED
  Heap_Block *const last_block = heap->last_block;                    
a000b9f8:	e58d302c 	str	r3, [sp, #44]	; 0x2c                          <== NOT EXECUTED
  Heap_Block *block = first_block;                                    
  Heap_Walk_printer printer = dump ?                                  
    _Heap_Walk_print : _Heap_Walk_print_nothing;                      
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
a000b9fc:	0a000002 	beq	a000ba0c <_Heap_Walk+0x58>                    <== NOT EXECUTED
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
a000ba00:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
}                                                                     
a000ba04:	e28dd038 	add	sp, sp, #56	; 0x38                            <== NOT EXECUTED
a000ba08:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  Heap_Block *const first_free_block = _Heap_Free_list_first( heap ); 
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  Heap_Block *const first_block = heap->first_block;                  
  Heap_Block *const last_block = heap->last_block;                    
                                                                      
  (*printer)(                                                         
a000ba0c:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
a000ba10:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
a000ba14:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
a000ba18:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a000ba1c:	e59dc028 	ldr	ip, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000ba20:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
a000ba24:	e59d102c 	ldr	r1, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a000ba28:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
a000ba2c:	e58d2014 	str	r2, [sp, #20]                                 <== NOT EXECUTED
a000ba30:	e58d1010 	str	r1, [sp, #16]                                 <== NOT EXECUTED
a000ba34:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
a000ba38:	e59f250c 	ldr	r2, [pc, #1292]	; a000bf4c <_Heap_Walk+0x598> <== NOT EXECUTED
a000ba3c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a000ba40:	e58d800c 	str	r8, [sp, #12]                                 <== NOT EXECUTED
a000ba44:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000ba48:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000ba4c:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ba50:	e12fff39 	blx	r9                                            <== NOT EXECUTED
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
a000ba54:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ba58:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000ba5c:	0a000024 	beq	a000baf4 <_Heap_Walk+0x140>                   <== NOT EXECUTED
    (*printer)( source, true, "page size is zero\n" );                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
a000ba60:	e59d3024 	ldr	r3, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ba64:	e2135007 	ands	r5, r3, #7                                   <== NOT EXECUTED
a000ba68:	1a000027 	bne	a000bb0c <_Heap_Walk+0x158>                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
a000ba6c:	e59d0028 	ldr	r0, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000ba70:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ba74:	ebffe56f 	bl	a0005038 <__umodsi3>                           <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
a000ba78:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
a000ba7c:	1a000028 	bne	a000bb24 <_Heap_Walk+0x170>                   <== NOT EXECUTED
a000ba80:	e2880008 	add	r0, r8, #8                                    <== NOT EXECUTED
a000ba84:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ba88:	ebffe56a 	bl	a0005038 <__umodsi3>                           <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
a000ba8c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a000ba90:	1a00002a 	bne	a000bb40 <_Heap_Walk+0x18c>                   <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000ba94:	e598b004 	ldr	fp, [r8, #4]                                  <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
a000ba98:	e21b5001 	ands	r5, fp, #1                                   <== NOT EXECUTED
a000ba9c:	0a0000f4 	beq	a000be74 <_Heap_Walk+0x4c0>                   <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000baa0:	e59dc02c 	ldr	ip, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a000baa4:	e59c3004 	ldr	r3, [ip, #4]                                  <== NOT EXECUTED
a000baa8:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000baac:	e08c3003 	add	r3, ip, r3                                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000bab0:	e5935004 	ldr	r5, [r3, #4]                                  <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
a000bab4:	e2155001 	ands	r5, r5, #1                                   <== NOT EXECUTED
a000bab8:	0a000007 	beq	a000badc <_Heap_Walk+0x128>                   <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
a000babc:	e1580003 	cmp	r8, r3                                        <== NOT EXECUTED
a000bac0:	0a000025 	beq	a000bb5c <_Heap_Walk+0x1a8>                   <== NOT EXECUTED
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
a000bac4:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bac8:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bacc:	e59f247c 	ldr	r2, [pc, #1148]	; a000bf50 <_Heap_Walk+0x59c> <== NOT EXECUTED
a000bad0:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bad4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000bad8:	eaffffc9 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
    (*printer)(                                                       
a000badc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bae0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bae4:	e59f2468 	ldr	r2, [pc, #1128]	; a000bf54 <_Heap_Walk+0x5a0> <== NOT EXECUTED
a000bae8:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000baec:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000baf0:	eaffffc3 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
    (*printer)( source, true, "page size is zero\n" );                
a000baf4:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000baf8:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bafc:	e59f2454 	ldr	r2, [pc, #1108]	; a000bf58 <_Heap_Walk+0x5a4> <== NOT EXECUTED
a000bb00:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bb04:	e59d0024 	ldr	r0, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000bb08:	eaffffbd 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
    (*printer)(                                                       
a000bb0c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bb10:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bb14:	e59f2440 	ldr	r2, [pc, #1088]	; a000bf5c <_Heap_Walk+0x5a8> <== NOT EXECUTED
a000bb18:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bb1c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bb20:	eaffffb7 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
    (*printer)(                                                       
a000bb24:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bb28:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bb2c:	e59f242c 	ldr	r2, [pc, #1068]	; a000bf60 <_Heap_Walk+0x5ac> <== NOT EXECUTED
a000bb30:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000bb34:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bb38:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000bb3c:	eaffffb0 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
  }                                                                   
                                                                      
  if (                                                                
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
a000bb40:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bb44:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bb48:	e59f2414 	ldr	r2, [pc, #1044]	; a000bf64 <_Heap_Walk+0x5b0> <== NOT EXECUTED
a000bb4c:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a000bb50:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bb54:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a000bb58:	eaffffa9 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000bb5c:	e5946008 	ldr	r6, [r4, #8]                                  <== NOT EXECUTED
  int source,                                                         
  Heap_Walk_printer printer,                                          
  Heap_Control *heap                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
a000bb60:	e5947010 	ldr	r7, [r4, #16]                                 <== NOT EXECUTED
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
a000bb64:	e1540006 	cmp	r4, r6                                        <== NOT EXECUTED
a000bb68:	05943020 	ldreq	r3, [r4, #32]                               <== NOT EXECUTED
a000bb6c:	0a00002b 	beq	a000bc20 <_Heap_Walk+0x26c>                   <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000bb70:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000bb74:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a000bb78:	8a0000c3 	bhi	a000be8c <_Heap_Walk+0x4d8>                   <== NOT EXECUTED
a000bb7c:	e594c024 	ldr	ip, [r4, #36]	; 0x24                          <== NOT EXECUTED
a000bb80:	e15c0006 	cmp	ip, r6                                        <== NOT EXECUTED
a000bb84:	3a0000c0 	bcc	a000be8c <_Heap_Walk+0x4d8>                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
a000bb88:	e2860008 	add	r0, r6, #8                                    <== NOT EXECUTED
a000bb8c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000bb90:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
a000bb94:	e58dc01c 	str	ip, [sp, #28]                                 <== NOT EXECUTED
a000bb98:	ebffe526 	bl	a0005038 <__umodsi3>                           <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
a000bb9c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000bba0:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
a000bba4:	e59dc01c 	ldr	ip, [sp, #28]                                 <== NOT EXECUTED
a000bba8:	1a0000d2 	bne	a000bef8 <_Heap_Walk+0x544>                   <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000bbac:	e5962004 	ldr	r2, [r6, #4]                                  <== NOT EXECUTED
a000bbb0:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000bbb4:	e0862002 	add	r2, r6, r2                                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000bbb8:	e5922004 	ldr	r2, [r2, #4]                                  <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
a000bbbc:	e3120001 	tst	r2, #1                                        <== NOT EXECUTED
a000bbc0:	1a0000dc 	bne	a000bf38 <_Heap_Walk+0x584>                   <== NOT EXECUTED
a000bbc4:	e58d8030 	str	r8, [sp, #48]	; 0x30                          <== NOT EXECUTED
a000bbc8:	e58db034 	str	fp, [sp, #52]	; 0x34                          <== NOT EXECUTED
a000bbcc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000bbd0:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
a000bbd4:	e1a0b00c 	mov	fp, ip                                        <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
a000bbd8:	e596100c 	ldr	r1, [r6, #12]                                 <== NOT EXECUTED
a000bbdc:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000bbe0:	1a0000cc 	bne	a000bf18 <_Heap_Walk+0x564>                   <== NOT EXECUTED
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    prev_block = free_block;                                          
    free_block = free_block->next;                                    
a000bbe4:	e5965008 	ldr	r5, [r6, #8]                                  <== NOT EXECUTED
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
  const Heap_Block *prev_block = free_list_tail;                      
  const Heap_Block *free_block = first_free_block;                    
                                                                      
  while ( free_block != free_list_tail ) {                            
a000bbe8:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000bbec:	0a000008 	beq	a000bc14 <_Heap_Walk+0x260>                   <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000bbf0:	e1580005 	cmp	r8, r5                                        <== NOT EXECUTED
a000bbf4:	9a000077 	bls	a000bdd8 <_Heap_Walk+0x424>                   <== NOT EXECUTED
    if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {              
      (*printer)(                                                     
a000bbf8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bbfc:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bc00:	e59f2360 	ldr	r2, [pc, #864]	; a000bf68 <_Heap_Walk+0x5b4>  <== NOT EXECUTED
a000bc04:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a000bc08:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bc0c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bc10:	eaffff7b 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
a000bc14:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a000bc18:	e59db034 	ldr	fp, [sp, #52]	; 0x34                          <== NOT EXECUTED
a000bc1c:	e59d8030 	ldr	r8, [sp, #48]	; 0x30                          <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
a000bc20:	e1a06008 	mov	r6, r8                                        <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000bc24:	e3cb7001 	bic	r7, fp, #1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
a000bc28:	e0875006 	add	r5, r7, r6                                    <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000bc2c:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a000bc30:	9a000007 	bls	a000bc54 <_Heap_Walk+0x2a0>                   <== NOT EXECUTED
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {              
      (*printer)(                                                     
a000bc34:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bc38:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
a000bc3c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bc40:	e59f2324 	ldr	r2, [pc, #804]	; a000bf6c <_Heap_Walk+0x5b8>  <== NOT EXECUTED
a000bc44:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bc48:	e12fff39 	blx	r9                                            <== NOT EXECUTED
        "block 0x%08x: next block 0x%08x not in heap\n",              
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
a000bc4c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bc50:	eaffff6b 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
a000bc54:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
a000bc58:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a000bc5c:	3afffff4 	bcc	a000bc34 <_Heap_Walk+0x280>                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
a000bc60:	e59d1024 	ldr	r1, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000bc64:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000bc68:	ebffe4f2 	bl	a0005038 <__umodsi3>                           <== NOT EXECUTED
    uintptr_t const block_begin = (uintptr_t) block;                  
    uintptr_t const block_size = _Heap_Block_size( block );           
    bool const prev_used = _Heap_Is_prev_used( block );               
    Heap_Block *const next_block = _Heap_Block_at( block, block_size );
    uintptr_t const next_block_begin = (uintptr_t) next_block;        
    bool const is_not_last_block = block != last_block;               
a000bc6c:	e59d102c 	ldr	r1, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a000bc70:	e0563001 	subs	r3, r6, r1                                   <== NOT EXECUTED
a000bc74:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
a000bc78:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000bc7c:	0a000001 	beq	a000bc88 <_Heap_Walk+0x2d4>                   <== NOT EXECUTED
a000bc80:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000bc84:	1a000082 	bne	a000be94 <_Heap_Walk+0x4e0>                   <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
a000bc88:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000bc8c:	e1520007 	cmp	r2, r7                                        <== NOT EXECUTED
a000bc90:	9a000001 	bls	a000bc9c <_Heap_Walk+0x2e8>                   <== NOT EXECUTED
a000bc94:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000bc98:	1a000085 	bne	a000beb4 <_Heap_Walk+0x500>                   <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
a000bc9c:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
a000bca0:	3a000001 	bcc	a000bcac <_Heap_Walk+0x2f8>                   <== NOT EXECUTED
a000bca4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000bca8:	1a00008a 	bne	a000bed8 <_Heap_Walk+0x524>                   <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000bcac:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
a000bcb0:	e20bb001 	and	fp, fp, #1                                    <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
a000bcb4:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a000bcb8:	0a000016 	beq	a000bd18 <_Heap_Walk+0x364>                   <== NOT EXECUTED
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
a000bcbc:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
a000bcc0:	0a00000b 	beq	a000bcf4 <_Heap_Walk+0x340>                   <== NOT EXECUTED
      (*printer)(                                                     
a000bcc4:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000bcc8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bccc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000bcd0:	e59f2298 	ldr	r2, [pc, #664]	; a000bf70 <_Heap_Walk+0x5bc>  <== NOT EXECUTED
a000bcd4:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bcd8:	e12fff39 	blx	r9                                            <== NOT EXECUTED
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
a000bcdc:	e1580005 	cmp	r8, r5                                        <== NOT EXECUTED
a000bce0:	0affff46 	beq	a000ba00 <_Heap_Walk+0x4c>                    <== NOT EXECUTED
a000bce4:	e595b004 	ldr	fp, [r5, #4]                                  <== NOT EXECUTED
a000bce8:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a000bcec:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
a000bcf0:	eaffffcb 	b	a000bc24 <_Heap_Walk+0x270>                     <== NOT EXECUTED
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
a000bcf4:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000bcf8:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a000bcfc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bd00:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a000bd04:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
a000bd08:	e59f2264 	ldr	r2, [pc, #612]	; a000bf74 <_Heap_Walk+0x5c0>  <== NOT EXECUTED
a000bd0c:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bd10:	e12fff39 	blx	r9                                            <== NOT EXECUTED
a000bd14:	eafffff0 	b	a000bcdc <_Heap_Walk+0x328>                     <== NOT EXECUTED
    false,                                                            
    "block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",          
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
a000bd18:	e596200c 	ldr	r2, [r6, #12]                                 <== NOT EXECUTED
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
a000bd1c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000bd20:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
a000bd24:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000bd28:	059f0248 	ldreq	r0, [pc, #584]	; a000bf78 <_Heap_Walk+0x5c4><== NOT EXECUTED
a000bd2c:	0a000003 	beq	a000bd40 <_Heap_Walk+0x38c>                   <== NOT EXECUTED
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
a000bd30:	e59f3244 	ldr	r3, [pc, #580]	; a000bf7c <_Heap_Walk+0x5c8>  <== NOT EXECUTED
a000bd34:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
a000bd38:	e59f0240 	ldr	r0, [pc, #576]	; a000bf80 <_Heap_Walk+0x5cc>  <== NOT EXECUTED
a000bd3c:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
    block->next,                                                      
    block->next == last_free_block ?                                  
a000bd40:	e5963008 	ldr	r3, [r6, #8]                                  <== NOT EXECUTED
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
a000bd44:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
a000bd48:	059f1234 	ldreq	r1, [pc, #564]	; a000bf84 <_Heap_Walk+0x5d0><== NOT EXECUTED
a000bd4c:	0a000003 	beq	a000bd60 <_Heap_Walk+0x3ac>                   <== NOT EXECUTED
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
a000bd50:	e59fc230 	ldr	ip, [pc, #560]	; a000bf88 <_Heap_Walk+0x5d4>  <== NOT EXECUTED
a000bd54:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000bd58:	e59f1220 	ldr	r1, [pc, #544]	; a000bf80 <_Heap_Walk+0x5cc>  <== NOT EXECUTED
a000bd5c:	01a0100c 	moveq	r1, ip                                      <== NOT EXECUTED
  Heap_Block *const last_free_block = _Heap_Free_list_last( heap );   
  bool const prev_used = _Heap_Is_prev_used( block );                 
  uintptr_t const block_size = _Heap_Block_size( block );             
  Heap_Block *const next_block = _Heap_Block_at( block, block_size ); 
                                                                      
  (*printer)(                                                         
a000bd60:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a000bd64:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
a000bd68:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a000bd6c:	e58d1010 	str	r1, [sp, #16]                                 <== NOT EXECUTED
a000bd70:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bd74:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000bd78:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bd7c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000bd80:	e59f2204 	ldr	r2, [pc, #516]	; a000bf8c <_Heap_Walk+0x5d8>  <== NOT EXECUTED
a000bd84:	e12fff39 	blx	r9                                            <== NOT EXECUTED
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
a000bd88:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000bd8c:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
a000bd90:	1a000026 	bne	a000be30 <_Heap_Walk+0x47c>                   <== NOT EXECUTED
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
a000bd94:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
a000bd98:	0a00002e 	beq	a000be58 <_Heap_Walk+0x4a4>                   <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000bd9c:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
a000bda0:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000bda4:	0a000004 	beq	a000bdbc <_Heap_Walk+0x408>                   <== NOT EXECUTED
    if ( free_block == block ) {                                      
a000bda8:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
a000bdac:	0affffca 	beq	a000bcdc <_Heap_Walk+0x328>                   <== NOT EXECUTED
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
a000bdb0:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
  const Heap_Block *free_block = _Heap_Free_list_first( heap );       
                                                                      
  while ( free_block != free_list_tail ) {                            
a000bdb4:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000bdb8:	1afffffa 	bne	a000bda8 <_Heap_Walk+0x3f4>                   <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
a000bdbc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bdc0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bdc4:	e59f21c4 	ldr	r2, [pc, #452]	; a000bf90 <_Heap_Walk+0x5dc>  <== NOT EXECUTED
a000bdc8:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bdcc:	e12fff39 	blx	r9                                            <== NOT EXECUTED
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
a000bdd0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bdd4:	eaffff0a 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000bdd8:	e155000b 	cmp	r5, fp                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
a000bddc:	e2850008 	add	r0, r5, #8                                    <== NOT EXECUTED
a000bde0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000bde4:	8affff83 	bhi	a000bbf8 <_Heap_Walk+0x244>                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
a000bde8:	ebffe492 	bl	a0005038 <__umodsi3>                           <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
a000bdec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000bdf0:	1a000041 	bne	a000befc <_Heap_Walk+0x548>                   <== NOT EXECUTED
    - HEAP_BLOCK_HEADER_SIZE);                                        
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
a000bdf4:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
a000bdf8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000bdfc:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
a000be00:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
}                                                                     
a000be04:	e0833005 	add	r3, r3, r5                                    <== NOT EXECUTED
  block->size_and_flag = size | flag;                                 
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & HEAP_PREV_BLOCK_USED;                 
a000be08:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
a000be0c:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a000be10:	0affff70 	beq	a000bbd8 <_Heap_Walk+0x224>                   <== NOT EXECUTED
      (*printer)(                                                     
a000be14:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000be18:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000be1c:	e59f2170 	ldr	r2, [pc, #368]	; a000bf94 <_Heap_Walk+0x5e0>  <== NOT EXECUTED
a000be20:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a000be24:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000be28:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000be2c:	eafffef4 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
    (*printer)(                                                       
a000be30:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
a000be34:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000be38:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000be3c:	e58d5008 	str	r5, [sp, #8]                                  <== NOT EXECUTED
a000be40:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000be44:	e59f214c 	ldr	r2, [pc, #332]	; a000bf98 <_Heap_Walk+0x5e4>  <== NOT EXECUTED
a000be48:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000be4c:	e12fff39 	blx	r9                                            <== NOT EXECUTED
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
a000be50:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000be54:	eafffeea 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
    (*printer)(                                                       
a000be58:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000be5c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000be60:	e59f2134 	ldr	r2, [pc, #308]	; a000bf9c <_Heap_Walk+0x5e8>  <== NOT EXECUTED
a000be64:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000be68:	e12fff39 	blx	r9                                            <== NOT EXECUTED
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
a000be6c:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a000be70:	eafffee3 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
    (*printer)(                                                       
a000be74:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000be78:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000be7c:	e59f211c 	ldr	r2, [pc, #284]	; a000bfa0 <_Heap_Walk+0x5ec>  <== NOT EXECUTED
a000be80:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000be84:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000be88:	eafffedd 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
  const Heap_Control *heap,                                           
  const Heap_Block *block                                             
)                                                                     
{                                                                     
  return (uintptr_t) block >= (uintptr_t) heap->first_block           
    && (uintptr_t) block <= (uintptr_t) heap->last_block;             
a000be8c:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
a000be90:	eaffff58 	b	a000bbf8 <_Heap_Walk+0x244>                     <== NOT EXECUTED
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
      (*printer)(                                                     
a000be94:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000be98:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000be9c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bea0:	e59f20fc 	ldr	r2, [pc, #252]	; a000bfa4 <_Heap_Walk+0x5f0>  <== NOT EXECUTED
a000bea4:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bea8:	e12fff39 	blx	r9                                            <== NOT EXECUTED
        "block 0x%08x: block size %u not page aligned\n",             
        block,                                                        
        block_size                                                    
      );                                                              
                                                                      
      return false;                                                   
a000beac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000beb0:	eafffed3 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
      (*printer)(                                                     
a000beb4:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a000beb8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bebc:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000bec0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bec4:	e59f20dc 	ldr	r2, [pc, #220]	; a000bfa8 <_Heap_Walk+0x5f4>  <== NOT EXECUTED
a000bec8:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000becc:	e12fff39 	blx	r9                                            <== NOT EXECUTED
        block,                                                        
        block_size,                                                   
        min_block_size                                                
      );                                                              
                                                                      
      return false;                                                   
a000bed0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bed4:	eafffeca 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
      (*printer)(                                                     
a000bed8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bedc:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
a000bee0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bee4:	e59f20c0 	ldr	r2, [pc, #192]	; a000bfac <_Heap_Walk+0x5f8>  <== NOT EXECUTED
a000bee8:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000beec:	e12fff39 	blx	r9                                            <== NOT EXECUTED
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
a000bef0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bef4:	eafffec2 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
a000bef8:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
a000befc:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bf00:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bf04:	e59f20a4 	ldr	r2, [pc, #164]	; a000bfb0 <_Heap_Walk+0x5fc>  <== NOT EXECUTED
a000bf08:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a000bf0c:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bf10:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bf14:	eafffeba 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
      (*printer)(                                                     
a000bf18:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a000bf1c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bf20:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bf24:	e59f2088 	ldr	r2, [pc, #136]	; a000bfb4 <_Heap_Walk+0x600>  <== NOT EXECUTED
a000bf28:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a000bf2c:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
a000bf30:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000bf34:	eafffeb2 	b	a000ba04 <_Heap_Walk+0x50>                      <== NOT EXECUTED
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
a000bf38:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
a000bf3c:	eaffffb4 	b	a000be14 <_Heap_Walk+0x460>                     <== NOT EXECUTED
                                                                      

a000b95c <_Heap_Walk_print>: static void _Heap_Walk_print( int source, bool error, const char *fmt, ... ) {
a000b95c:	e92d000c 	push	{r2, r3}                                     <== NOT EXECUTED
a000b960:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  va_list ap;                                                         
                                                                      
  if ( error ) {                                                      
a000b964:	e31100ff 	tst	r1, #255	; 0xff                               <== NOT EXECUTED
{                                                                     
  /* Do nothing */                                                    
}                                                                     
                                                                      
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{                                                                     
a000b968:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000b96c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  va_list ap;                                                         
                                                                      
  if ( error ) {                                                      
a000b970:	1a00000a 	bne	a000b9a0 <_Heap_Walk_print+0x44>              <== NOT EXECUTED
    printk( "FAIL[%d]: ", source );                                   
  } else {                                                            
    printk( "PASS[%d]: ", source );                                   
a000b974:	e59f0030 	ldr	r0, [pc, #48]	; a000b9ac <_Heap_Walk_print+0x50><== NOT EXECUTED
a000b978:	ebfff036 	bl	a0007a58 <printk>                              <== NOT EXECUTED
  }                                                                   
                                                                      
  va_start( ap, fmt );                                                
a000b97c:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
  vprintk( fmt, ap );                                                 
a000b980:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
a000b984:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
    printk( "FAIL[%d]: ", source );                                   
  } else {                                                            
    printk( "PASS[%d]: ", source );                                   
  }                                                                   
                                                                      
  va_start( ap, fmt );                                                
a000b988:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  vprintk( fmt, ap );                                                 
a000b98c:	ebfff7b7 	bl	a0009870 <vprintk>                             <== NOT EXECUTED
  va_end( ap );                                                       
}                                                                     
a000b990:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000b994:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
a000b998:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000b99c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{                                                                     
  va_list ap;                                                         
                                                                      
  if ( error ) {                                                      
    printk( "FAIL[%d]: ", source );                                   
a000b9a0:	e59f0008 	ldr	r0, [pc, #8]	; a000b9b0 <_Heap_Walk_print+0x54><== NOT EXECUTED
a000b9a4:	ebfff02b 	bl	a0007a58 <printk>                              <== NOT EXECUTED
a000b9a8:	eafffff3 	b	a000b97c <_Heap_Walk_print+0x20>                <== NOT EXECUTED
                                                                      

a000b950 <_Heap_Walk_print_nothing>: int source, bool error, const char *fmt, ... ) {
a000b950:	e92d000c 	push	{r2, r3}                                     <== NOT EXECUTED
  /* Do nothing */                                                    
}                                                                     
a000b954:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000b958:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0017ca0 <_Message_queue_Allocate>: */ Message_queue_Control *_Message_queue_Allocate(void) { return (Message_queue_Control *) _Objects_Allocate(&_Message_queue_Information);
a0017ca0:	e59f0000 	ldr	r0, [pc, #0]	; a0017ca8 <_Message_queue_Allocate+0x8><== NOT EXECUTED
a0017ca4:	eafff047 	b	a0013dc8 <_Objects_Allocate>                    <== NOT EXECUTED
                                                                      

a00121e0 <_Message_queue_Translate_core_message_queue_return_code>: #if defined(RTEMS_DEBUG) if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ) return RTEMS_INTERNAL_ERROR; #endif return _Message_queue_Translate_core_return_code_[status];
a00121e0:	e59f3004 	ldr	r3, [pc, #4]	; a00121ec <_Message_queue_Translate_core_message_queue_return_code+0xc><== NOT EXECUTED
}                                                                     
a00121e4:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a00121e8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000f6d8 <_Objects_API_maximum_class>: #include <rtems/score/object.h> unsigned int _Objects_API_maximum_class( uint32_t api ) {
a000f6d8:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
a000f6dc:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a000f6e0:	959f3008 	ldrls	r3, [pc, #8]	; a000f6f0 <_Objects_API_maximum_class+0x18><== NOT EXECUTED
a000f6e4:	83a00000 	movhi	r0, #0                                      <== NOT EXECUTED
a000f6e8:	97930100 	ldrls	r0, [r3, r0, lsl #2]                        <== NOT EXECUTED
    case OBJECTS_NO_API:                                              
    default:                                                          
      break;                                                          
  }                                                                   
  return 0;                                                           
}                                                                     
a000f6ec:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000adb8 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) {
a000adb8:	e92d4070 	push	{r4, r5, r6, lr}                             
   *  If the application is using the optional manager stubs and      
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
a000adbc:	e5905018 	ldr	r5, [r0, #24]                                 
 */                                                                   
                                                                      
Objects_Control *_Objects_Allocate(                                   
  Objects_Information *information                                    
)                                                                     
{                                                                     
a000adc0:	e1a04000 	mov	r4, r0                                        
   *  If the application is using the optional manager stubs and      
   *  still attempts to create the object, the information block      
   *  should be all zeroed out because it is in the BSS.  So let's    
   *  check that code for this manager is even present.               
   */                                                                 
  if ( information->size == 0 )                                       
a000adc4:	e3550000 	cmp	r5, #0                                        
a000adc8:	1a000001 	bne	a000add4 <_Objects_Allocate+0x1c>             
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
a000adcc:	e1a00005 	mov	r0, r5                                        
a000add0:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      
  /*                                                                  
   *  OK.  The manager should be initialized and configured to have objects.
   *  With any luck, it is safe to attempt to allocate an object.     
   */                                                                 
  the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
a000add4:	e2806020 	add	r6, r0, #32                                   
a000add8:	e1a00006 	mov	r0, r6                                        
a000addc:	ebfffd95 	bl	a000a438 <_Chain_Get>                          
                                                                      
  if ( information->auto_extend ) {                                   
a000ade0:	e5d43012 	ldrb	r3, [r4, #18]                                
                                                                      
  /*                                                                  
   *  OK.  The manager should be initialized and configured to have objects.
   *  With any luck, it is safe to attempt to allocate an object.     
   */                                                                 
  the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
a000ade4:	e1a05000 	mov	r5, r0                                        
                                                                      
  if ( information->auto_extend ) {                                   
a000ade8:	e3530000 	cmp	r3, #0                                        
a000adec:	0afffff6 	beq	a000adcc <_Objects_Allocate+0x14>             
    /*                                                                
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
a000adf0:	e3500000 	cmp	r0, #0                                        
a000adf4:	0a00000d 	beq	a000ae30 <_Objects_Allocate+0x78>             
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
a000adf8:	e1d430b8 	ldrh	r3, [r4, #8]                                 
a000adfc:	e1d500b8 	ldrh	r0, [r5, #8]                                 
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
a000ae00:	e1d411b4 	ldrh	r1, [r4, #20]                                
a000ae04:	e0630000 	rsb	r0, r3, r0                                    
a000ae08:	eb002677 	bl	a00147ec <__aeabi_uidiv>                       
                                                                      
      information->inactive_per_block[ block ]--;                     
a000ae0c:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          
      information->inactive--;                                        
a000ae10:	e1d422bc 	ldrh	r2, [r4, #44]	; 0x2c                         
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
                                                                      
      information->inactive_per_block[ block ]--;                     
a000ae14:	e7931100 	ldr	r1, [r3, r0, lsl #2]                          
      information->inactive--;                                        
a000ae18:	e2422001 	sub	r2, r2, #1                                    
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
                                                                      
      information->inactive_per_block[ block ]--;                     
a000ae1c:	e2411001 	sub	r1, r1, #1                                    
a000ae20:	e7831100 	str	r1, [r3, r0, lsl #2]                          
      information->inactive--;                                        
a000ae24:	e1c422bc 	strh	r2, [r4, #44]	; 0x2c                         
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
a000ae28:	e1a00005 	mov	r0, r5                                        
a000ae2c:	e8bd8070 	pop	{r4, r5, r6, pc}                              
     *  If the list is empty then we are out of objects and need to   
     *  extend information base.                                      
     */                                                               
                                                                      
    if ( !the_object ) {                                              
      _Objects_Extend_information( information );                     
a000ae30:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ae34:	eb000009 	bl	a000ae60 <_Objects_Extend_information>         <== NOT EXECUTED
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
a000ae38:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000ae3c:	ebfffd7d 	bl	a000a438 <_Chain_Get>                          <== NOT EXECUTED
    }                                                                 
                                                                      
    if ( the_object ) {                                               
a000ae40:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a000ae44:	0affffe0 	beq	a000adcc <_Objects_Allocate+0x14>             <== NOT EXECUTED
a000ae48:	eaffffea 	b	a000adf8 <_Objects_Allocate+0x40>               <== NOT EXECUTED
                                                                      

a000ae60 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) {
a000ae60:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
a000ae64:	e5904034 	ldr	r4, [r0, #52]	; 0x34                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
a000ae68:	e24dd014 	sub	sp, sp, #20                                   
a000ae6c:	e1a05000 	mov	r5, r0                                        
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
a000ae70:	e3540000 	cmp	r4, #0                                        
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
a000ae74:	e1d070b8 	ldrh	r7, [r0, #8]                                 
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
a000ae78:	0a00009a 	beq	a000b0e8 <_Objects_Extend_information+0x288>  
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
a000ae7c:	e1d081b4 	ldrh	r8, [r0, #20]                                <== NOT EXECUTED
a000ae80:	e1d0a1b0 	ldrh	sl, [r0, #16]                                <== NOT EXECUTED
a000ae84:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000ae88:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000ae8c:	eb002656 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
a000ae90:	e1a03800 	lsl	r3, r0, #16                                   <== NOT EXECUTED
                                                                      
    for ( ; block < block_count; block++ ) {                          
a000ae94:	e1b03823 	lsrs	r3, r3, #16                                  <== NOT EXECUTED
a000ae98:	0a000098 	beq	a000b100 <_Objects_Extend_information+0x2a0>  <== NOT EXECUTED
      if ( information->object_blocks[ block ] == NULL ) {            
a000ae9c:	e5949000 	ldr	r9, [r4]                                      <== NOT EXECUTED
a000aea0:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a000aea4:	01a01008 	moveq	r1, r8                                      <== NOT EXECUTED
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
a000aea8:	01a06007 	moveq	r6, r7                                      <== NOT EXECUTED
  index_base    = minimum_index;                                      
  block         = 0;                                                  
a000aeac:	01a04009 	moveq	r4, r9                                      <== NOT EXECUTED
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
a000aeb0:	0a00000c 	beq	a000aee8 <_Objects_Extend_information+0x88>   <== NOT EXECUTED
a000aeb4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000aeb8:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
a000aebc:	e1a06007 	mov	r6, r7                                        <== NOT EXECUTED
  index_base    = minimum_index;                                      
  block         = 0;                                                  
a000aec0:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a000aec4:	ea000002 	b	a000aed4 <_Objects_Extend_information+0x74>     <== NOT EXECUTED
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
      if ( information->object_blocks[ block ] == NULL ) {            
a000aec8:	e5b29004 	ldr	r9, [r2, #4]!                                 <== NOT EXECUTED
a000aecc:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a000aed0:	0a000004 	beq	a000aee8 <_Objects_Extend_information+0x88>   <== NOT EXECUTED
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
a000aed4:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
a000aed8:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
        break;                                                        
      } else                                                          
        index_base += information->allocation_size;                   
a000aedc:	e0866008 	add	r6, r6, r8                                    <== NOT EXECUTED
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
a000aee0:	8afffff8 	bhi	a000aec8 <_Objects_Extend_information+0x68>   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
a000aee4:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
a000aee8:	e08aa001 	add	sl, sl, r1                                    
  /*                                                                  
   *  We need to limit the number of objects to the maximum number    
   *  representable in the index portion of the object Id.  In the    
   *  case of 16-bit Ids, this is only 256 object instances.          
   */                                                                 
  if ( maximum > OBJECTS_ID_FINAL_INDEX ) {                           
a000aeec:	e35a0801 	cmp	sl, #65536	; 0x10000                          
a000aef0:	2a000062 	bcs	a000b080 <_Objects_Extend_information+0x220>  
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
  if ( information->auto_extend ) {                                   
a000aef4:	e5d52012 	ldrb	r2, [r5, #18]                                
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
a000aef8:	e5950018 	ldr	r0, [r5, #24]                                 
  if ( information->auto_extend ) {                                   
a000aefc:	e3520000 	cmp	r2, #0                                        
                                                                      
  /*                                                                  
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
a000af00:	e0000091 	mul	r0, r1, r0                                    
  if ( information->auto_extend ) {                                   
a000af04:	1a00005f 	bne	a000b088 <_Objects_Extend_information+0x228>  
    new_object_block = _Workspace_Allocate( block_size );             
    if ( !new_object_block )                                          
      return;                                                         
  } else {                                                            
    new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
a000af08:	e58d3000 	str	r3, [sp]                                      
a000af0c:	eb00088f 	bl	a000d150 <_Workspace_Allocate_or_fatal_error>  
a000af10:	e59d3000 	ldr	r3, [sp]                                      
a000af14:	e1a08000 	mov	r8, r0                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Do we need to grow the tables?                                  
   */                                                                 
  if ( do_extend ) {                                                  
a000af18:	e3590000 	cmp	r9, #0                                        
a000af1c:	0a000038 	beq	a000b004 <_Objects_Extend_information+0x1a4>  
     */                                                               
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
    block_count++;                                                    
a000af20:	e283b001 	add	fp, r3, #1                                    
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
a000af24:	e08b008b 	add	r0, fp, fp, lsl #1                            
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
a000af28:	e08a0000 	add	r0, sl, r0                                    
                                                                      
    /*                                                                
     *  Allocate the tables and break it up.                          
     */                                                               
    block_size = block_count *                                        
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
a000af2c:	e0800007 	add	r0, r0, r7                                    
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    object_blocks = (void**) _Workspace_Allocate( block_size );       
a000af30:	e1a00100 	lsl	r0, r0, #2                                    
a000af34:	e58d3000 	str	r3, [sp]                                      
a000af38:	eb00087a 	bl	a000d128 <_Workspace_Allocate>                 
                                                                      
    if ( !object_blocks ) {                                           
a000af3c:	e2509000 	subs	r9, r0, #0                                   
a000af40:	e59d3000 	ldr	r3, [sp]                                      
a000af44:	0a000072 	beq	a000b114 <_Objects_Extend_information+0x2b4>  
     *  Take the block count down. Saves all the (block_count - 1)    
     *  in the copies.                                                
     */                                                               
    block_count--;                                                    
                                                                      
    if ( information->maximum > minimum_index ) {                     
a000af48:	e1d521b0 	ldrh	r2, [r5, #16]                                
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (                    
  const void *base,                                                   
  uintptr_t   offset                                                  
)                                                                     
{                                                                     
  return (void *)((uintptr_t)base + offset);                          
a000af4c:	e089c10b 	add	ip, r9, fp, lsl #2                            
a000af50:	e089b18b 	add	fp, r9, fp, lsl #3                            
a000af54:	e1570002 	cmp	r7, r2                                        
a000af58:	3a000050 	bcc	a000b0a0 <_Objects_Extend_information+0x240>  
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
a000af5c:	e3570000 	cmp	r7, #0                                        
a000af60:	13a02000 	movne	r2, #0                                      
a000af64:	11a0100b 	movne	r1, fp                                      
        local_table[ index ] = NULL;                                  
a000af68:	11a00002 	movne	r0, r2                                      
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
a000af6c:	0a000003 	beq	a000af80 <_Objects_Extend_information+0x120>  
a000af70:	e2822001 	add	r2, r2, #1                                    
a000af74:	e1570002 	cmp	r7, r2                                        
        local_table[ index ] = NULL;                                  
a000af78:	e4810004 	str	r0, [r1], #4                                  
    } else {                                                          
                                                                      
      /*                                                              
       *  Deal with the special case of the 0 to minimum_index        
       */                                                             
      for ( index = 0; index < minimum_index; index++ ) {             
a000af7c:	8afffffb 	bhi	a000af70 <_Objects_Extend_information+0x110>  
a000af80:	e1a03103 	lsl	r3, r3, #2                                    
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
a000af84:	e1d511b4 	ldrh	r1, [r5, #20]                                
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
a000af88:	e3a00000 	mov	r0, #0                                        
a000af8c:	e7890003 	str	r0, [r9, r3]                                  
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
a000af90:	e0861001 	add	r1, r6, r1                                    
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
a000af94:	e1560001 	cmp	r6, r1                                        
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
a000af98:	e78c0003 	str	r0, [ip, r3]                                  
                                                                      
    for ( index=index_base ;                                          
a000af9c:	2a000005 	bcs	a000afb8 <_Objects_Extend_information+0x158>  
a000afa0:	e08b2106 	add	r2, fp, r6, lsl #2                            
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
a000afa4:	e1a03006 	mov	r3, r6                                        
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
a000afa8:	e2833001 	add	r3, r3, #1                                    
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
a000afac:	e1530001 	cmp	r3, r1                                        
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
a000afb0:	e4820004 	str	r0, [r2], #4                                  
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
a000afb4:	3afffffb 	bcc	a000afa8 <_Objects_Extend_information+0x148>  
a000afb8:	e10f3000 	mrs	r3, CPSR                                      
a000afbc:	e3832080 	orr	r2, r3, #128	; 0x80                           
a000afc0:	e129f002 	msr	CPSR_fc, r2                                   
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
a000afc4:	e5952000 	ldr	r2, [r5]                                      
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
a000afc8:	e1d510b4 	ldrh	r1, [r5, #4]                                 
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
    information->maximum = (Objects_Maximum) maximum;                 
a000afcc:	e1a0a80a 	lsl	sl, sl, #16                                   
a000afd0:	e1a02c02 	lsl	r2, r2, #24                                   
a000afd4:	e3822801 	orr	r2, r2, #65536	; 0x10000                      
a000afd8:	e1a0a82a 	lsr	sl, sl, #16                                   
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
a000afdc:	e1822d81 	orr	r2, r2, r1, lsl #27                           
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
a000afe0:	e182200a 	orr	r2, r2, sl                                    
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
a000afe4:	e5950034 	ldr	r0, [r5, #52]	; 0x34                          
                                                                      
    information->object_blocks = object_blocks;                       
    information->inactive_per_block = inactive_per_block;             
a000afe8:	e585c030 	str	ip, [r5, #48]	; 0x30                          
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
a000afec:	e5859034 	str	r9, [r5, #52]	; 0x34                          
    information->inactive_per_block = inactive_per_block;             
    information->local_table = local_table;                           
a000aff0:	e585b01c 	str	fp, [r5, #28]                                 
    information->maximum = (Objects_Maximum) maximum;                 
a000aff4:	e1c5a1b0 	strh	sl, [r5, #16]                                
    information->maximum_id = _Objects_Build_id(                      
a000aff8:	e585200c 	str	r2, [r5, #12]                                 
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000affc:	e129f003 	msr	CPSR_fc, r3                                   
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
                                                                      
    _Workspace_Free( old_tables );                                    
a000b000:	eb00084e 	bl	a000d140 <_Workspace_Free>                     
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
a000b004:	e5953034 	ldr	r3, [r5, #52]	; 0x34                          
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
a000b008:	e28d7008 	add	r7, sp, #8                                    
a000b00c:	e1a01008 	mov	r1, r8                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
a000b010:	e7838104 	str	r8, [r3, r4, lsl #2]                          
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
a000b014:	e1a00007 	mov	r0, r7                                        
a000b018:	e1d521b4 	ldrh	r2, [r5, #20]                                
a000b01c:	e5953018 	ldr	r3, [r5, #24]                                 
a000b020:	eb001022 	bl	a000f0b0 <_Chain_Initialize>                   
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
a000b024:	e1a04104 	lsl	r4, r4, #2                                    
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
a000b028:	e2858020 	add	r8, r5, #32                                   
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
a000b02c:	ea000009 	b	a000b058 <_Objects_Extend_information+0x1f8>    
a000b030:	e5953000 	ldr	r3, [r5]                                      
                                                                      
    the_object->id = _Objects_Build_id(                               
a000b034:	e1d520b4 	ldrh	r2, [r5, #4]                                 
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
a000b038:	e1a00008 	mov	r0, r8                                        
a000b03c:	e1a03c03 	lsl	r3, r3, #24                                   
a000b040:	e3833801 	orr	r3, r3, #65536	; 0x10000                      
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
a000b044:	e1833d82 	orr	r3, r3, r2, lsl #27                           
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
a000b048:	e1833006 	orr	r3, r3, r6                                    
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
                                                                      
    the_object->id = _Objects_Build_id(                               
a000b04c:	e5813008 	str	r3, [r1, #8]                                  
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
a000b050:	ebfffce5 	bl	a000a3ec <_Chain_Append>                       
                                                                      
    index++;                                                          
a000b054:	e2866001 	add	r6, r6, #1                                    
  /*                                                                  
   *  Move from the local chain, initialise, then append to the inactive chain
   */                                                                 
  index = index_base;                                                 
                                                                      
  while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
a000b058:	e1a00007 	mov	r0, r7                                        
a000b05c:	ebfffcf5 	bl	a000a438 <_Chain_Get>                          
a000b060:	e2501000 	subs	r1, r0, #0                                   
a000b064:	1afffff1 	bne	a000b030 <_Objects_Extend_information+0x1d0>  
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
a000b068:	e1d522bc 	ldrh	r2, [r5, #44]	; 0x2c                         
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
a000b06c:	e1d531b4 	ldrh	r3, [r5, #20]                                
a000b070:	e5951030 	ldr	r1, [r5, #48]	; 0x30                          
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
a000b074:	e0832002 	add	r2, r3, r2                                    
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
a000b078:	e7813004 	str	r3, [r1, r4]                                  
  information->inactive =                                             
a000b07c:	e1c522bc 	strh	r2, [r5, #44]	; 0x2c                         
    (Objects_Maximum)(information->inactive + information->allocation_size);
}                                                                     
a000b080:	e28dd014 	add	sp, sp, #20                                   
a000b084:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
   * Allocate the name table, and the objects and if it fails either return or
   * generate a fatal error depending on auto-extending being active. 
   */                                                                 
  block_size = information->allocation_size * information->size;      
  if ( information->auto_extend ) {                                   
    new_object_block = _Workspace_Allocate( block_size );             
a000b088:	e58d3000 	str	r3, [sp]                                      
a000b08c:	eb000825 	bl	a000d128 <_Workspace_Allocate>                 
    if ( !new_object_block )                                          
a000b090:	e2508000 	subs	r8, r0, #0                                   
a000b094:	e59d3000 	ldr	r3, [sp]                                      
a000b098:	1affff9e 	bne	a000af18 <_Objects_Extend_information+0xb8>   
a000b09c:	eafffff7 	b	a000b080 <_Objects_Extend_information+0x220>    <== NOT EXECUTED
      /*                                                              
       *  Copy each section of the table over. This has to be performed as
       *  separate parts as size of each block has changed.           
       */                                                             
                                                                      
      memcpy( object_blocks,                                          
a000b0a0:	e1a03103 	lsl	r3, r3, #2                                    <== NOT EXECUTED
a000b0a4:	e5951034 	ldr	r1, [r5, #52]	; 0x34                          <== NOT EXECUTED
a000b0a8:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000b0ac:	e88d1008 	stm	sp, {r3, ip}                                  <== NOT EXECUTED
a000b0b0:	eb001a38 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
a000b0b4:	e89d1008 	ldm	sp, {r3, ip}                                  <== NOT EXECUTED
a000b0b8:	e5951030 	ldr	r1, [r5, #48]	; 0x30                          <== NOT EXECUTED
a000b0bc:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
a000b0c0:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000b0c4:	eb001a33 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
a000b0c8:	e1d521b0 	ldrh	r2, [r5, #16]                                <== NOT EXECUTED
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
a000b0cc:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a000b0d0:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
a000b0d4:	e0872002 	add	r2, r7, r2                                    <== NOT EXECUTED
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
              information->inactive_per_block,                        
              block_count * sizeof(uint32_t) );                       
      memcpy( local_table,                                            
a000b0d8:	e1a02102 	lsl	r2, r2, #2                                    <== NOT EXECUTED
a000b0dc:	eb001a2d 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
a000b0e0:	e89d1008 	ldm	sp, {r3, ip}                                  <== NOT EXECUTED
a000b0e4:	eaffffa6 	b	a000af84 <_Objects_Extend_information+0x124>    <== NOT EXECUTED
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
a000b0e8:	e1d0a1b0 	ldrh	sl, [r0, #16]                                
a000b0ec:	e1d011b4 	ldrh	r1, [r0, #20]                                
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
a000b0f0:	e1a06007 	mov	r6, r7                                        
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
a000b0f4:	e3a09001 	mov	r9, #1                                        
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
a000b0f8:	e1a03004 	mov	r3, r4                                        
a000b0fc:	eaffff79 	b	a000aee8 <_Objects_Extend_information+0x88>     
  else {                                                              
    block_count = information->maximum / information->allocation_size;
                                                                      
    for ( ; block < block_count; block++ ) {                          
a000b100:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
  minimum_index = _Objects_Get_index( information->minimum_id );      
a000b104:	e1a06007 	mov	r6, r7                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Search for a free block of indexes. If we do NOT need to allocate or
   *  extend the block table, then we will change do_extend.          
   */                                                                 
  do_extend     = true;                                               
a000b108:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
a000b10c:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
a000b110:	eaffff74 	b	a000aee8 <_Objects_Extend_information+0x88>     <== NOT EXECUTED
           (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    object_blocks = (void**) _Workspace_Allocate( block_size );       
                                                                      
    if ( !object_blocks ) {                                           
      _Workspace_Free( new_object_block );                            
a000b114:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000b118:	eb000808 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
      return;                                                         
a000b11c:	eaffffd7 	b	a000b080 <_Objects_Extend_information+0x220>    <== NOT EXECUTED
                                                                      

a000b120 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) {
a000b120:	e92d4070 	push	{r4, r5, r6, lr}                             
a000b124:	e1a04000 	mov	r4, r0                                        
  uint32_t    allocation_size = information->allocation_size;         
                                                                      
  _Chain_Append( &information->Inactive, &the_object->Node );         
a000b128:	e2800020 	add	r0, r0, #32                                   
                                                                      
void _Objects_Free(                                                   
  Objects_Information *information,                                   
  Objects_Control     *the_object                                     
)                                                                     
{                                                                     
a000b12c:	e1a06001 	mov	r6, r1                                        
  uint32_t    allocation_size = information->allocation_size;         
a000b130:	e1d451b4 	ldrh	r5, [r4, #20]                                
                                                                      
  _Chain_Append( &information->Inactive, &the_object->Node );         
a000b134:	ebfffcac 	bl	a000a3ec <_Chain_Append>                       
                                                                      
  if ( information->auto_extend ) {                                   
a000b138:	e5d43012 	ldrb	r3, [r4, #18]                                
a000b13c:	e3530000 	cmp	r3, #0                                        
a000b140:	0a000010 	beq	a000b188 <_Objects_Free+0x68>                 
    uint32_t    block;                                                
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
a000b144:	e1d430b8 	ldrh	r3, [r4, #8]                                 <== NOT EXECUTED
a000b148:	e1d600b8 	ldrh	r0, [r6, #8]                                 <== NOT EXECUTED
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
a000b14c:	e1d411b4 	ldrh	r1, [r4, #20]                                <== NOT EXECUTED
    /*                                                                
     *  Check if the threshold level has been met of                  
     *  1.5 x allocation_size are free.                               
     */                                                               
                                                                      
    if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
a000b150:	e08550a5 	add	r5, r5, r5, lsr #1                            <== NOT EXECUTED
  if ( information->auto_extend ) {                                   
    uint32_t    block;                                                
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
a000b154:	e0630000 	rsb	r0, r3, r0                                    <== NOT EXECUTED
a000b158:	eb0025a3 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
                                                                      
    information->inactive_per_block[ block ]++;                       
    information->inactive++;                                          
a000b15c:	e1d432bc 	ldrh	r3, [r4, #44]	; 0x2c                         <== NOT EXECUTED
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
                                                                      
    information->inactive_per_block[ block ]++;                       
a000b160:	e5942030 	ldr	r2, [r4, #48]	; 0x30                          <== NOT EXECUTED
    information->inactive++;                                          
a000b164:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
                                                                      
    information->inactive_per_block[ block ]++;                       
a000b168:	e7921100 	ldr	r1, [r2, r0, lsl #2]                          <== NOT EXECUTED
    information->inactive++;                                          
a000b16c:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
a000b170:	e1a03823 	lsr	r3, r3, #16                                   <== NOT EXECUTED
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
                                                                      
    information->inactive_per_block[ block ]++;                       
a000b174:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
    /*                                                                
     *  Check if the threshold level has been met of                  
     *  1.5 x allocation_size are free.                               
     */                                                               
                                                                      
    if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
a000b178:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
                                                                      
    block = (uint32_t) (_Objects_Get_index( the_object->id ) -        
                        _Objects_Get_index( information->minimum_id ));
    block /= information->allocation_size;                            
                                                                      
    information->inactive_per_block[ block ]++;                       
a000b17c:	e7821100 	str	r1, [r2, r0, lsl #2]                          <== NOT EXECUTED
    information->inactive++;                                          
a000b180:	e1c432bc 	strh	r3, [r4, #44]	; 0x2c                         <== NOT EXECUTED
    /*                                                                
     *  Check if the threshold level has been met of                  
     *  1.5 x allocation_size are free.                               
     */                                                               
                                                                      
    if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
a000b184:	8a000000 	bhi	a000b18c <_Objects_Free+0x6c>                 <== NOT EXECUTED
a000b188:	e8bd8070 	pop	{r4, r5, r6, pc}                              
      _Objects_Shrink_information( information );                     
a000b18c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
}                                                                     
a000b190:	e8bd4070 	pop	{r4, r5, r6, lr}                              <== NOT EXECUTED
     *  Check if the threshold level has been met of                  
     *  1.5 x allocation_size are free.                               
     */                                                               
                                                                      
    if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
      _Objects_Shrink_information( information );                     
a000b194:	ea0000b1 	b	a000b460 <_Objects_Shrink_information>          <== NOT EXECUTED
                                                                      

a000b284 <_Objects_Get>: * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
a000b284:	e590c008 	ldr	ip, [r0, #8]                                  
                                                                      
  /*                                                                  
   *  If the index is less than maximum, then it is OK to use it to   
   *  index into the local_table array.                               
   */                                                                 
  if ( index <= information->maximum ) {                              
a000b288:	e1d031b0 	ldrh	r3, [r0, #16]                                
Objects_Control *_Objects_Get(                                        
  Objects_Information *information,                                   
  Objects_Id           id,                                            
  Objects_Locations   *location                                       
)                                                                     
{                                                                     
a000b28c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
   *  always NULL.                                                    
   *                                                                  
   *  If the Id is valid but the object has not been created yet, then
   *  the local_table entry will be NULL.                             
   */                                                                 
  index = id - information->minimum_id + 1;                           
a000b290:	e26cc001 	rsb	ip, ip, #1                                    
a000b294:	e08cc001 	add	ip, ip, r1                                    
                                                                      
  /*                                                                  
   *  If the index is less than maximum, then it is OK to use it to   
   *  index into the local_table array.                               
   */                                                                 
  if ( index <= information->maximum ) {                              
a000b298:	e15c0003 	cmp	ip, r3                                        
  /*                                                                  
   *  Object Id is not within this API and Class on this node.  So    
   *  it may be global in a multiprocessing system.  But it is clearly
   *  invalid on a single processor system.                           
   */                                                                 
  *location = OBJECTS_ERROR;                                          
a000b29c:	83a03001 	movhi	r3, #1                                      
Objects_Control *_Objects_Get(                                        
  Objects_Information *information,                                   
  Objects_Id           id,                                            
  Objects_Locations   *location                                       
)                                                                     
{                                                                     
a000b2a0:	e24dd008 	sub	sp, sp, #8                                    
  /*                                                                  
   *  Object Id is not within this API and Class on this node.  So    
   *  it may be global in a multiprocessing system.  But it is clearly
   *  invalid on a single processor system.                           
   */                                                                 
  *location = OBJECTS_ERROR;                                          
a000b2a4:	85823000 	strhi	r3, [r2]                                    
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  _Objects_MP_Is_remote( information, id, location, &the_object );    
  return the_object;                                                  
#else                                                                 
  return NULL;                                                        
a000b2a8:	83a00000 	movhi	r0, #0                                      
                                                                      
  /*                                                                  
   *  If the index is less than maximum, then it is OK to use it to   
   *  index into the local_table array.                               
   */                                                                 
  if ( index <= information->maximum ) {                              
a000b2ac:	8a000009 	bhi	a000b2d8 <_Objects_Get+0x54>                  
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000b2b0:	e59f3048 	ldr	r3, [pc, #72]	; a000b300 <_Objects_Get+0x7c>  
a000b2b4:	e5931000 	ldr	r1, [r3]                                      
a000b2b8:	e2811001 	add	r1, r1, #1                                    
a000b2bc:	e5831000 	str	r1, [r3]                                      
    _Thread_Disable_dispatch();                                       
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a000b2c0:	e590301c 	ldr	r3, [r0, #28]                                 
a000b2c4:	e793010c 	ldr	r0, [r3, ip, lsl #2]                          
a000b2c8:	e3500000 	cmp	r0, #0                                        
      *location = OBJECTS_LOCAL;                                      
a000b2cc:	13a03000 	movne	r3, #0                                      
a000b2d0:	15823000 	strne	r3, [r2]                                    
   *  If the index is less than maximum, then it is OK to use it to   
   *  index into the local_table array.                               
   */                                                                 
  if ( index <= information->maximum ) {                              
    _Thread_Disable_dispatch();                                       
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a000b2d4:	0a000001 	beq	a000b2e0 <_Objects_Get+0x5c>                  
  _Objects_MP_Is_remote( information, id, location, &the_object );    
  return the_object;                                                  
#else                                                                 
  return NULL;                                                        
#endif                                                                
}                                                                     
a000b2d8:	e28dd008 	add	sp, sp, #8                                    
a000b2dc:	e8bd8000 	pop	{pc}                                          
                                                                      
    /*                                                                
     *  Valid Id for this API, Class and Node but the object has not  
     *  been allocated yet.                                           
     */                                                               
    _Thread_Enable_dispatch();                                        
a000b2e0:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
a000b2e4:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000b2e8:	eb000338 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    *location = OBJECTS_ERROR;                                        
a000b2ec:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a000b2f0:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
    return NULL;                                                      
a000b2f4:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
    /*                                                                
     *  Valid Id for this API, Class and Node but the object has not  
     *  been allocated yet.                                           
     */                                                               
    _Thread_Enable_dispatch();                                        
    *location = OBJECTS_ERROR;                                        
a000b2f8:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    return NULL;                                                      
a000b2fc:	eafffff5 	b	a000b2d8 <_Objects_Get+0x54>                    <== NOT EXECUTED
                                                                      

a000b1ac <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) {
a000b1ac:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a000b1b0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
a000b1b4:	e1b04821 	lsrs	r4, r1, #16                                  <== NOT EXECUTED
                                                                      
Objects_Information *_Objects_Get_information(                        
  Objects_APIs   the_api,                                             
  uint16_t       the_class                                            
)                                                                     
{                                                                     
a000b1b8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
a000b1bc:	1a000001 	bne	a000b1c8 <_Objects_Get_information+0x1c>      <== NOT EXECUTED
    return NULL;                                                      
a000b1c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b1c4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This call implicitly validates the_api so we do not call        
   *  _Objects_Is_api_valid above here.                               
   */                                                                 
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
a000b1c8:	eb001142 	bl	a000f6d8 <_Objects_API_maximum_class>          <== NOT EXECUTED
  if ( the_class_api_maximum == 0 )                                   
a000b1cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b1d0:	1a000000 	bne	a000b1d8 <_Objects_Get_information+0x2c>      <== NOT EXECUTED
    if ( info->maximum == 0 )                                         
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
a000b1d4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
   */                                                                 
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
  if ( the_class_api_maximum == 0 )                                   
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
a000b1d8:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
    return NULL;                                                      
a000b1dc:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
   */                                                                 
  the_class_api_maximum = _Objects_API_maximum_class( the_api );      
  if ( the_class_api_maximum == 0 )                                   
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
a000b1e0:	3afffffb 	bcc	a000b1d4 <_Objects_Get_information+0x28>      <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
a000b1e4:	e59f3024 	ldr	r3, [pc, #36]	; a000b210 <_Objects_Get_information+0x64><== NOT EXECUTED
a000b1e8:	e7930105 	ldr	r0, [r3, r5, lsl #2]                          <== NOT EXECUTED
a000b1ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b1f0:	0afffff7 	beq	a000b1d4 <_Objects_Get_information+0x28>      <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
a000b1f4:	e7900104 	ldr	r0, [r0, r4, lsl #2]                          <== NOT EXECUTED
  if ( !info )                                                        
a000b1f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b1fc:	0afffff4 	beq	a000b1d4 <_Objects_Get_information+0x28>      <== NOT EXECUTED
   *  In a multprocessing configuration, we may access remote objects.
   *  Thus we may have 0 local instances and still have a valid object
   *  pointer.                                                        
   */                                                                 
  #if !defined(RTEMS_MULTIPROCESSING)                                 
    if ( info->maximum == 0 )                                         
a000b200:	e1d031b0 	ldrh	r3, [r0, #16]                                <== NOT EXECUTED
      return NULL;                                                    
a000b204:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b208:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
a000b20c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000b198 <_Objects_Get_information_id>: #include <rtems/score/thread.h> Objects_Information *_Objects_Get_information_id( Objects_Id id ) {
a000b198:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(                   
  Objects_Id id                                                       
)                                                                     
{                                                                     
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
a000b19c:	e1a00c20 	lsr	r0, r0, #24                                   <== NOT EXECUTED
  return _Objects_Get_information(                                    
a000b1a0:	e2000007 	and	r0, r0, #7                                    <== NOT EXECUTED
a000b1a4:	e1a01da1 	lsr	r1, r1, #27                                   <== NOT EXECUTED
a000b1a8:	eaffffff 	b	a000b1ac <_Objects_Get_information>             <== NOT EXECUTED
                                                                      

a000b214 <_Objects_Get_isr_disable>: { Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1;
a000b214:	e590c008 	ldr	ip, [r0, #8]                                  
  Objects_Information *information,                                   
  Objects_Id           id,                                            
  Objects_Locations   *location,                                      
  ISR_Level           *level_p                                        
)                                                                     
{                                                                     
a000b218:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 
  Objects_Control *the_object;                                        
  uint32_t         index;                                             
  ISR_Level        level;                                             
                                                                      
  index = id - information->minimum_id + 1;                           
a000b21c:	e26cc001 	rsb	ip, ip, #1                                    
a000b220:	e08cc001 	add	ip, ip, r1                                    
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000b224:	e10f4000 	mrs	r4, CPSR                                      
a000b228:	e3841080 	orr	r1, r4, #128	; 0x80                           
a000b22c:	e129f001 	msr	CPSR_fc, r1                                   
                                                                      
  _ISR_Disable( level );                                              
  if ( information->maximum >= index ) {                              
a000b230:	e1d011b0 	ldrh	r1, [r0, #16]                                
a000b234:	e15c0001 	cmp	ip, r1                                        
a000b238:	8a000008 	bhi	a000b260 <_Objects_Get_isr_disable+0x4c>      
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a000b23c:	e590101c 	ldr	r1, [r0, #28]                                 
a000b240:	e791010c 	ldr	r0, [r1, ip, lsl #2]                          
a000b244:	e3500000 	cmp	r0, #0                                        
      *location = OBJECTS_LOCAL;                                      
a000b248:	13a01000 	movne	r1, #0                                      
a000b24c:	15821000 	strne	r1, [r2]                                    
      *level_p = level;                                               
a000b250:	15834000 	strne	r4, [r3]                                    
                                                                      
  index = id - information->minimum_id + 1;                           
                                                                      
  _ISR_Disable( level );                                              
  if ( information->maximum >= index ) {                              
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a000b254:	0a000006 	beq	a000b274 <_Objects_Get_isr_disable+0x60>      
  _Objects_MP_Is_remote( information, id, location, &the_object );    
  return the_object;                                                  
#else                                                                 
  return NULL;                                                        
#endif                                                                
}                                                                     
a000b258:	e8bd0010 	pop	{r4}                                          
a000b25c:	e12fff1e 	bx	lr                                             
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000b260:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
    *location = OBJECTS_ERROR;                                        
    return NULL;                                                      
  }                                                                   
  _ISR_Enable( level );                                               
  *location = OBJECTS_ERROR;                                          
a000b264:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000b268:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  _Objects_MP_Is_remote( information, id, location, &the_object );    
  return the_object;                                                  
#else                                                                 
  return NULL;                                                        
a000b26c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000b270:	eafffff8 	b	a000b258 <_Objects_Get_isr_disable+0x44>        <== NOT EXECUTED
a000b274:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
      *location = OBJECTS_LOCAL;                                      
      *level_p = level;                                               
      return the_object;                                              
    }                                                                 
    _ISR_Enable( level );                                             
    *location = OBJECTS_ERROR;                                        
a000b278:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000b27c:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    return NULL;                                                      
a000b280:	eafffff4 	b	a000b258 <_Objects_Get_isr_disable+0x44>        <== NOT EXECUTED
                                                                      

a000cde8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) {
a000cde8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  char                   lname[5];                                    
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
a000cdec:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
char *_Objects_Get_name_as_string(                                    
  Objects_Id        id,                                               
  size_t            length,                                           
  char             *name                                              
)                                                                     
{                                                                     
a000cdf0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a000cdf4:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
    return NULL;                                                      
a000cdf8:	01a04005 	moveq	r4, r5                                      <== NOT EXECUTED
  char                   lname[5];                                    
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
a000cdfc:	1a000002 	bne	a000ce0c <_Objects_Get_name_as_string+0x24>   <== NOT EXECUTED
                                                                      
      _Thread_Enable_dispatch();                                      
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
a000ce00:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ce04:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a000ce08:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
    return NULL;                                                      
                                                                      
  if ( name == NULL )                                                 
a000ce0c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000ce10:	0afffffa 	beq	a000ce00 <_Objects_Get_name_as_string+0x18>   <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
a000ce14:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ce18:	059f30c4 	ldreq	r3, [pc, #196]	; a000cee4 <_Objects_Get_name_as_string+0xfc><== NOT EXECUTED
a000ce1c:	11a06000 	movne	r6, r0                                      <== NOT EXECUTED
a000ce20:	05933004 	ldreq	r3, [r3, #4]                                <== NOT EXECUTED
a000ce24:	05936008 	ldreq	r6, [r3, #8]                                <== NOT EXECUTED
                                                                      
  information = _Objects_Get_information_id( tmpId );                 
a000ce28:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000ce2c:	ebffffb2 	bl	a000ccfc <_Objects_Get_information_id>         <== NOT EXECUTED
  if ( !information )                                                 
a000ce30:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    return NULL;                                                      
a000ce34:	01a04003 	moveq	r4, r3                                      <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
                                                                      
  information = _Objects_Get_information_id( tmpId );                 
  if ( !information )                                                 
a000ce38:	0afffff0 	beq	a000ce00 <_Objects_Get_name_as_string+0x18>   <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
a000ce3c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000ce40:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a000ce44:	eb000028 	bl	a000ceec <_Objects_Get>                        <== NOT EXECUTED
  switch ( location ) {                                               
a000ce48:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a000ce4c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:                                              
      /* not supported */                                             
#endif                                                                
    case OBJECTS_ERROR:                                               
      return NULL;                                                    
a000ce50:	13a04000 	movne	r4, #0                                      <== NOT EXECUTED
  information = _Objects_Get_information_id( tmpId );                 
  if ( !information )                                                 
    return NULL;                                                      
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
  switch ( location ) {                                               
a000ce54:	1affffe9 	bne	a000ce00 <_Objects_Get_name_as_string+0x18>   <== NOT EXECUTED
        if ( information->is_string ) {                               
          s = the_object->name.name_p;                                
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
a000ce58:	e590100c 	ldr	r1, [r0, #12]                                 <== NOT EXECUTED
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
a000ce5c:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
        lname[ 4 ] = '\0';                                            
a000ce60:	e5cd3004 	strb	r3, [sp, #4]                                 <== NOT EXECUTED
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
a000ce64:	e1a02c21 	lsr	r2, r1, #24                                   <== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
a000ce68:	e1a0c821 	lsr	ip, r1, #16                                   <== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
a000ce6c:	e1a00421 	lsr	r0, r1, #8                                    <== NOT EXECUTED
        } else                                                        
      #endif                                                          
      {                                                               
        uint32_t  u32_name = (uint32_t) the_object->name.name_u32;    
                                                                      
        lname[ 0 ] = (u32_name >> 24) & 0xff;                         
a000ce70:	e5cd2000 	strb	r2, [sp]                                     <== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
a000ce74:	e5cdc001 	strb	ip, [sp, #1]                                 <== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
a000ce78:	e5cd0002 	strb	r0, [sp, #2]                                 <== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
a000ce7c:	e5cd1003 	strb	r1, [sp, #3]                                 <== NOT EXECUTED
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
a000ce80:	0a000015 	beq	a000cedc <_Objects_Get_name_as_string+0xf4>   <== NOT EXECUTED
a000ce84:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000ce88:	0a000013 	beq	a000cedc <_Objects_Get_name_as_string+0xf4>   <== NOT EXECUTED
a000ce8c:	e59fc054 	ldr	ip, [pc, #84]	; a000cee8 <_Objects_Get_name_as_string+0x100><== NOT EXECUTED
a000ce90:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000ce94:	ea000002 	b	a000cea4 <_Objects_Get_name_as_string+0xbc>     <== NOT EXECUTED
a000ce98:	e7dd2003 	ldrb	r2, [sp, r3]                                 <== NOT EXECUTED
a000ce9c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000cea0:	0a000009 	beq	a000cecc <_Objects_Get_name_as_string+0xe4>   <== NOT EXECUTED
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
a000cea4:	e59c0000 	ldr	r0, [ip]                                      <== NOT EXECUTED
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
a000cea8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
a000ceac:	e0800002 	add	r0, r0, r2                                    <== NOT EXECUTED
a000ceb0:	e5d00001 	ldrb	r0, [r0, #1]                                 <== NOT EXECUTED
a000ceb4:	e3100097 	tst	r0, #151	; 0x97                               <== NOT EXECUTED
a000ceb8:	03a0202a 	moveq	r2, #42	; 0x2a                              <== NOT EXECUTED
a000cebc:	e4c12001 	strb	r2, [r1], #1                                 <== NOT EXECUTED
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
a000cec0:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a000cec4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000cec8:	3afffff2 	bcc	a000ce98 <_Objects_Get_name_as_string+0xb0>   <== NOT EXECUTED
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
        }                                                             
      }                                                               
      *d = '\0';                                                      
a000cecc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ced0:	e5c03000 	strb	r3, [r0]                                     <== NOT EXECUTED
                                                                      
      _Thread_Enable_dispatch();                                      
a000ced4:	eb000335 	bl	a000dbb0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return name;                                                    
a000ced8:	eaffffc8 	b	a000ce00 <_Objects_Get_name_as_string+0x18>     <== NOT EXECUTED
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
a000cedc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000cee0:	eafffff9 	b	a000cecc <_Objects_Get_name_as_string+0xe4>     <== NOT EXECUTED
                                                                      

a000b44c <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) {
a000b44c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
a000b450:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
    Objects_Information *information,                                 
    Objects_Id           id,                                          
    Objects_Locations   *location_p,                                  
    Objects_Id          *next_id_p                                    
)                                                                     
{                                                                     
a000b454:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a000b458:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
a000b45c:	1a000001 	bne	a000b468 <_Objects_Get_next+0x1c>             <== NOT EXECUTED
      return NULL;                                                    
a000b460:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b464:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
    if ( !location_p )                                                
a000b468:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000b46c:	1a000001 	bne	a000b478 <_Objects_Get_next+0x2c>             <== NOT EXECUTED
      return NULL;                                                    
a000b470:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a000b474:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
    if ( !next_id_p )                                                 
a000b478:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b47c:	0a000016 	beq	a000b4dc <_Objects_Get_next+0x90>             <== NOT EXECUTED
      return NULL;                                                    
                                                                      
    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)           
a000b480:	e1b03801 	lsls	r3, r1, #16                                  <== NOT EXECUTED
        next_id = information->minimum_id;                            
a000b484:	05946008 	ldreq	r6, [r4, #8]                                <== NOT EXECUTED
    else                                                              
        next_id = id;                                                 
a000b488:	11a06001 	movne	r6, r1                                      <== NOT EXECUTED
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
a000b48c:	e1d4c1b0 	ldrh	ip, [r4, #16]                                <== NOT EXECUTED
a000b490:	e1a07806 	lsl	r7, r6, #16                                   <== NOT EXECUTED
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
a000b494:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
a000b498:	e15c0827 	cmp	ip, r7, lsr #16                               <== NOT EXECUTED
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
a000b49c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b4a0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    else                                                              
        next_id = id;                                                 
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
a000b4a4:	3a000006 	bcc	a000b4c4 <_Objects_Get_next+0x78>             <== NOT EXECUTED
            *location_p = OBJECTS_ERROR;                              
            goto final;                                               
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
a000b4a8:	eb00000d 	bl	a000b4e4 <_Objects_Get>                        <== NOT EXECUTED
                                                                      
        next_id++;                                                    
                                                                      
    } while (*location_p != OBJECTS_LOCAL);                           
a000b4ac:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
        }                                                             
                                                                      
        /* try to grab one */                                         
        object = _Objects_Get(information, next_id, location_p);      
                                                                      
        next_id++;                                                    
a000b4b0:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
                                                                      
    } while (*location_p != OBJECTS_LOCAL);                           
a000b4b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b4b8:	1afffff3 	bne	a000b48c <_Objects_Get_next+0x40>             <== NOT EXECUTED
                                                                      
    *next_id_p = next_id;                                             
a000b4bc:	e5886000 	str	r6, [r8]                                      <== NOT EXECUTED
    return object;                                                    
a000b4c0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
    do {                                                              
        /* walked off end of list? */                                 
        if (_Objects_Get_index(next_id) > information->maximum)       
        {                                                             
            *location_p = OBJECTS_ERROR;                              
a000b4c4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000b4c8:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
a000b4cc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
    return 0;                                                         
a000b4d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
a000b4d4:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
    return 0;                                                         
a000b4d8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
    if ( !location_p )                                                
      return NULL;                                                    
                                                                      
    if ( !next_id_p )                                                 
      return NULL;                                                    
a000b4dc:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
    return 0;                                                         
}                                                                     
a000b4e0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a001cbf4 <_Objects_Get_no_protection>: /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1;
a001cbf4:	e590c008 	ldr	ip, [r0, #8]                                  <== NOT EXECUTED
                                                                      
  if ( information->maximum >= index ) {                              
a001cbf8:	e1d031b0 	ldrh	r3, [r0, #16]                                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * You can't just extract the index portion or you can get tricked  
   * by a value between 1 and maximum.                                
   */                                                                 
  index = id - information->minimum_id + 1;                           
a001cbfc:	e26cc001 	rsb	ip, ip, #1                                    <== NOT EXECUTED
a001cc00:	e08cc001 	add	ip, ip, r1                                    <== NOT EXECUTED
                                                                      
  if ( information->maximum >= index ) {                              
a001cc04:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
a001cc08:	8a000005 	bhi	a001cc24 <_Objects_Get_no_protection+0x30>    <== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a001cc0c:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
a001cc10:	e793010c 	ldr	r0, [r3, ip, lsl #2]                          <== NOT EXECUTED
a001cc14:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      *location = OBJECTS_LOCAL;                                      
a001cc18:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a001cc1c:	15823000 	strne	r3, [r2]                                    <== NOT EXECUTED
   * by a value between 1 and maximum.                                
   */                                                                 
  index = id - information->minimum_id + 1;                           
                                                                      
  if ( information->maximum >= index ) {                              
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
a001cc20:	112fff1e 	bxne	lr                                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This isn't supported or required yet for Global objects so      
   *  if it isn't local, we don't find it.                            
   */                                                                 
  *location = OBJECTS_ERROR;                                          
a001cc24:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a001cc28:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
  return NULL;                                                        
a001cc2c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a001cc30:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000c994 <_Objects_Id_to_name>: /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
a000c994:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000c998:	059f3078 	ldreq	r3, [pc, #120]	; a000ca18 <_Objects_Id_to_name+0x84><== NOT EXECUTED
 */                                                                   
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (                
  Objects_Id      id,                                                 
  Objects_Name   *name                                                
)                                                                     
{                                                                     
a000c99c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Caller is trusted for name != NULL.                             
   */                                                                 
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
a000c9a0:	05933004 	ldreq	r3, [r3, #4]                                <== NOT EXECUTED
 */                                                                   
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (                
  Objects_Id      id,                                                 
  Objects_Name   *name                                                
)                                                                     
{                                                                     
a000c9a4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Caller is trusted for name != NULL.                             
   */                                                                 
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
a000c9a8:	11a01000 	movne	r1, r0                                      <== NOT EXECUTED
a000c9ac:	05931008 	ldreq	r1, [r3, #8]                                <== NOT EXECUTED
 */                                                                   
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (                
  Objects_Id      id,                                                 
  Objects_Name   *name                                                
)                                                                     
{                                                                     
a000c9b0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000c9b4:	e1a03c21 	lsr	r3, r1, #24                                   <== NOT EXECUTED
a000c9b8:	e2033007 	and	r3, r3, #7                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(                      
  uint32_t   the_api                                                  
)                                                                     
{                                                                     
  if ( !the_api || the_api > OBJECTS_APIS_LAST )                      
a000c9bc:	e2432001 	sub	r2, r3, #1                                    <== NOT EXECUTED
a000c9c0:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
a000c9c4:	8a000010 	bhi	a000ca0c <_Objects_Id_to_name+0x78>           <== NOT EXECUTED
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
a000c9c8:	e59f204c 	ldr	r2, [pc, #76]	; a000ca1c <_Objects_Id_to_name+0x88><== NOT EXECUTED
a000c9cc:	e7923103 	ldr	r3, [r2, r3, lsl #2]                          <== NOT EXECUTED
a000c9d0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c9d4:	0a00000c 	beq	a000ca0c <_Objects_Id_to_name+0x78>           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(                     
  Objects_Id id                                                       
)                                                                     
{                                                                     
  return (uint32_t)                                                   
a000c9d8:	e1a02da1 	lsr	r2, r1, #27                                   <== NOT EXECUTED
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
a000c9dc:	e7930102 	ldr	r0, [r3, r2, lsl #2]                          <== NOT EXECUTED
  if ( !information )                                                 
a000c9e0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000c9e4:	0a000008 	beq	a000ca0c <_Objects_Id_to_name+0x78>           <== NOT EXECUTED
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
      return OBJECTS_INVALID_ID;                                      
  #endif                                                              
                                                                      
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
a000c9e8:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000c9ec:	ebffffc8 	bl	a000c914 <_Objects_Get>                        <== NOT EXECUTED
  if ( !the_object )                                                  
a000c9f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000c9f4:	0a000004 	beq	a000ca0c <_Objects_Id_to_name+0x78>           <== NOT EXECUTED
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
a000c9f8:	e590300c 	ldr	r3, [r0, #12]                                 <== NOT EXECUTED
a000c9fc:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a000ca00:	eb000339 	bl	a000d6ec <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
a000ca04:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000ca08:	ea000000 	b	a000ca10 <_Objects_Id_to_name+0x7c>             <== NOT EXECUTED
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
    return OBJECTS_INVALID_ID;                                        
a000ca0c:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
}                                                                     
a000ca10:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000ca14:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000b3d8 <_Objects_Name_to_id_u32>: Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id )
a000b3d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  Objects_Information *information,                                   
  uint32_t             name,                                          
  uint32_t             node,                                          
  Objects_Id          *id                                             
)                                                                     
{                                                                     
a000b3dc:	e92d0030 	push	{r4, r5}                                     <== NOT EXECUTED
#endif                                                                
                                                                      
  /* ASSERT: information->is_string == false */                       
                                                                      
  if ( !id )                                                          
    return OBJECTS_INVALID_ADDRESS;                                   
a000b3e0:	03a00002 	moveq	r0, #2                                      <== NOT EXECUTED
  Objects_Name               name_for_mp;                             
#endif                                                                
                                                                      
  /* ASSERT: information->is_string == false */                       
                                                                      
  if ( !id )                                                          
a000b3e4:	0a000005 	beq	a000b400 <_Objects_Name_to_id_u32+0x28>       <== NOT EXECUTED
    return OBJECTS_INVALID_ADDRESS;                                   
                                                                      
  if ( name == 0 )                                                    
a000b3e8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000b3ec:	0a000002 	beq	a000b3fc <_Objects_Name_to_id_u32+0x24>       <== NOT EXECUTED
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  search_local_node = false;                                          
                                                                      
  if ( information->maximum != 0 &&                                   
a000b3f0:	e1d051b0 	ldrh	r5, [r0, #16]                                <== NOT EXECUTED
a000b3f4:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000b3f8:	1a000002 	bne	a000b408 <_Objects_Name_to_id_u32+0x30>       <== NOT EXECUTED
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  name_for_mp.name_u32 = name;                                        
  return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else                                                                 
  return OBJECTS_INVALID_NAME;                                        
a000b3fc:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
#endif                                                                
}                                                                     
a000b400:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
a000b404:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  if ( name == 0 )                                                    
    return OBJECTS_INVALID_NAME;                                      
                                                                      
  search_local_node = false;                                          
                                                                      
  if ( information->maximum != 0 &&                                   
a000b408:	e3720106 	cmn	r2, #-2147483647	; 0x80000001                 <== NOT EXECUTED
a000b40c:	13520000 	cmpne	r2, #0                                      <== NOT EXECUTED
a000b410:	1a00000b 	bne	a000b444 <_Objects_Name_to_id_u32+0x6c>       <== NOT EXECUTED
       _Objects_Is_local_node( node )                                 
      ))                                                              
   search_local_node = true;                                          
                                                                      
  if ( search_local_node ) {                                          
    for ( index = 1; index <= information->maximum; index++ ) {       
a000b414:	e590c01c 	ldr	ip, [r0, #28]                                 <== NOT EXECUTED
a000b418:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
      the_object = information->local_table[ index ];                 
a000b41c:	e5bc0004 	ldr	r0, [ip, #4]!                                 <== NOT EXECUTED
       _Objects_Is_local_node( node )                                 
      ))                                                              
   search_local_node = true;                                          
                                                                      
  if ( search_local_node ) {                                          
    for ( index = 1; index <= information->maximum; index++ ) {       
a000b420:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
      the_object = information->local_table[ index ];                 
      if ( !the_object )                                              
a000b424:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b428:	0a000002 	beq	a000b438 <_Objects_Name_to_id_u32+0x60>       <== NOT EXECUTED
        continue;                                                     
                                                                      
      if ( name == the_object->name.name_u32 ) {                      
a000b42c:	e590400c 	ldr	r4, [r0, #12]                                 <== NOT EXECUTED
a000b430:	e1540001 	cmp	r4, r1                                        <== NOT EXECUTED
a000b434:	0a000005 	beq	a000b450 <_Objects_Name_to_id_u32+0x78>       <== NOT EXECUTED
       _Objects_Is_local_node( node )                                 
      ))                                                              
   search_local_node = true;                                          
                                                                      
  if ( search_local_node ) {                                          
    for ( index = 1; index <= information->maximum; index++ ) {       
a000b438:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
a000b43c:	2afffff6 	bcs	a000b41c <_Objects_Name_to_id_u32+0x44>       <== NOT EXECUTED
a000b440:	eaffffed 	b	a000b3fc <_Objects_Name_to_id_u32+0x24>         <== NOT EXECUTED
                                                                      
  search_local_node = false;                                          
                                                                      
  if ( information->maximum != 0 &&                                   
      (node == OBJECTS_SEARCH_ALL_NODES ||                            
       node == OBJECTS_SEARCH_LOCAL_NODE ||                           
a000b444:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
a000b448:	1affffeb 	bne	a000b3fc <_Objects_Name_to_id_u32+0x24>       <== NOT EXECUTED
a000b44c:	eafffff0 	b	a000b414 <_Objects_Name_to_id_u32+0x3c>         <== NOT EXECUTED
      the_object = information->local_table[ index ];                 
      if ( !the_object )                                              
        continue;                                                     
                                                                      
      if ( name == the_object->name.name_u32 ) {                      
        *id = the_object->id;                                         
a000b450:	e5902008 	ldr	r2, [r0, #8]                                  <== NOT EXECUTED
        return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                  
a000b454:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      the_object = information->local_table[ index ];                 
      if ( !the_object )                                              
        continue;                                                     
                                                                      
      if ( name == the_object->name.name_u32 ) {                      
        *id = the_object->id;                                         
a000b458:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
        return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                  
a000b45c:	eaffffe7 	b	a000b400 <_Objects_Name_to_id_u32+0x28>         <== NOT EXECUTED
                                                                      

a000d910 <_Objects_Set_name>: { size_t length; const char *s; s = name; length = strnlen( name, information->name_length );
a000d910:	e1d033b8 	ldrh	r3, [r0, #56]	; 0x38                         <== NOT EXECUTED
bool _Objects_Set_name(                                               
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
a000d914:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  size_t                 length;                                      
  const char            *s;                                           
                                                                      
  s      = name;                                                      
  length = strnlen( name, information->name_length );                 
a000d918:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
bool _Objects_Set_name(                                               
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
a000d91c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  size_t                 length;                                      
  const char            *s;                                           
                                                                      
  s      = name;                                                      
  length = strnlen( name, information->name_length );                 
a000d920:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
bool _Objects_Set_name(                                               
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
a000d924:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  size_t                 length;                                      
  const char            *s;                                           
                                                                      
  s      = name;                                                      
  length = strnlen( name, information->name_length );                 
a000d928:	eb001d76 	bl	a0014f08 <strnlen>                             <== NOT EXECUTED
    d[length] = '\0';                                                 
    the_object->name.name_p = d;                                      
  } else                                                              
#endif                                                                
  {                                                                   
    the_object->name.name_u32 =  _Objects_Build_name(                 
a000d92c:	e5d42000 	ldrb	r2, [r4]                                     <== NOT EXECUTED
a000d930:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000d934:	e1a02c02 	lsl	r2, r2, #24                                   <== NOT EXECUTED
a000d938:	9a00000c 	bls	a000d970 <_Objects_Set_name+0x60>             <== NOT EXECUTED
a000d93c:	e5d43001 	ldrb	r3, [r4, #1]                                 <== NOT EXECUTED
a000d940:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a000d944:	e1822803 	orr	r2, r2, r3, lsl #16                           <== NOT EXECUTED
a000d948:	0a000009 	beq	a000d974 <_Objects_Set_name+0x64>             <== NOT EXECUTED
a000d94c:	e5d43002 	ldrb	r3, [r4, #2]                                 <== NOT EXECUTED
a000d950:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
    );                                                                
                                                                      
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
a000d954:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    d[length] = '\0';                                                 
    the_object->name.name_p = d;                                      
  } else                                                              
#endif                                                                
  {                                                                   
    the_object->name.name_u32 =  _Objects_Build_name(                 
a000d958:	e1822403 	orr	r2, r2, r3, lsl #8                            <== NOT EXECUTED
a000d95c:	15d43003 	ldrbne	r3, [r4, #3]                               <== NOT EXECUTED
a000d960:	03a03020 	moveq	r3, #32                                     <== NOT EXECUTED
a000d964:	e1823003 	orr	r3, r2, r3                                    <== NOT EXECUTED
a000d968:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
    );                                                                
                                                                      
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
a000d96c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    d[length] = '\0';                                                 
    the_object->name.name_p = d;                                      
  } else                                                              
#endif                                                                
  {                                                                   
    the_object->name.name_u32 =  _Objects_Build_name(                 
a000d970:	e3822602 	orr	r2, r2, #2097152	; 0x200000                   <== NOT EXECUTED
a000d974:	e3822a02 	orr	r2, r2, #8192	; 0x2000                        <== NOT EXECUTED
a000d978:	e3a03020 	mov	r3, #32                                       <== NOT EXECUTED
a000d97c:	e1823003 	orr	r3, r2, r3                                    <== NOT EXECUTED
a000d980:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
    );                                                                
                                                                      
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
a000d984:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000d988:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000b460 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) {
a000b460:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
a000b464:	e1d040b8 	ldrh	r4, [r0, #8]                                 <== NOT EXECUTED
  block_count = (information->maximum - index_base) /                 
a000b468:	e1d051b4 	ldrh	r5, [r0, #20]                                <== NOT EXECUTED
 */                                                                   
                                                                      
void _Objects_Shrink_information(                                     
  Objects_Information *information                                    
)                                                                     
{                                                                     
a000b46c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  /*                                                                  
   * Search the list to find block or chunk with all objects inactive.
   */                                                                 
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
a000b470:	e1d001b0 	ldrh	r0, [r0, #16]                                <== NOT EXECUTED
a000b474:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000b478:	e0640000 	rsb	r0, r4, r0                                    <== NOT EXECUTED
a000b47c:	eb0024da 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
a000b480:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b484:	0a00000d 	beq	a000b4c0 <_Objects_Shrink_information+0x60>   <== NOT EXECUTED
    if ( information->inactive_per_block[ block ] ==                  
a000b488:	e5962030 	ldr	r2, [r6, #48]	; 0x30                          <== NOT EXECUTED
a000b48c:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
a000b490:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
a000b494:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
    if ( information->inactive_per_block[ block ] ==                  
a000b498:	1a000005 	bne	a000b4b4 <_Objects_Shrink_information+0x54>   <== NOT EXECUTED
a000b49c:	ea000008 	b	a000b4c4 <_Objects_Shrink_information+0x64>     <== NOT EXECUTED
a000b4a0:	e5b21004 	ldr	r1, [r2, #4]!                                 <== NOT EXECUTED
      information->inactive -= information->allocation_size;          
                                                                      
      return;                                                         
    }                                                                 
                                                                      
    index_base += information->allocation_size;                       
a000b4a4:	e0844005 	add	r4, r4, r5                                    <== NOT EXECUTED
a000b4a8:	e1a07103 	lsl	r7, r3, #2                                    <== NOT EXECUTED
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
    if ( information->inactive_per_block[ block ] ==                  
a000b4ac:	e1550001 	cmp	r5, r1                                        <== NOT EXECUTED
a000b4b0:	0a000004 	beq	a000b4c8 <_Objects_Shrink_information+0x68>   <== NOT EXECUTED
                                                                      
  index_base = _Objects_Get_index( information->minimum_id );         
  block_count = (information->maximum - index_base) /                 
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
a000b4b4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000b4b8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000b4bc:	8afffff7 	bhi	a000b4a0 <_Objects_Shrink_information+0x40>   <== NOT EXECUTED
a000b4c0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    if ( information->inactive_per_block[ block ] ==                  
a000b4c4:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
         information->allocation_size ) {                             
                                                                      
      /*                                                              
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
a000b4c8:	e5960020 	ldr	r0, [r6, #32]                                 <== NOT EXECUTED
a000b4cc:	ea000002 	b	a000b4dc <_Objects_Shrink_information+0x7c>     <== NOT EXECUTED
         if ((index >= index_base) &&                                 
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
         }                                                            
       }                                                              
       while ( the_object );                                          
a000b4d0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000b4d4:	0a00000b 	beq	a000b508 <_Objects_Shrink_information+0xa8>   <== NOT EXECUTED
         index = _Objects_Get_index( the_object->id );                
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
a000b4d8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
       *  Assume the Inactive chain is never empty at this point      
       */                                                             
      the_object = (Objects_Control *) _Chain_First( &information->Inactive );
                                                                      
      do {                                                            
         index = _Objects_Get_index( the_object->id );                
a000b4dc:	e1d030b8 	ldrh	r3, [r0, #8]                                 <== NOT EXECUTED
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
a000b4e0:	e5905000 	ldr	r5, [r0]                                      <== NOT EXECUTED
         if ((index >= index_base) &&                                 
a000b4e4:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000b4e8:	3afffff8 	bcc	a000b4d0 <_Objects_Shrink_information+0x70>   <== NOT EXECUTED
             (index < (index_base + information->allocation_size))) { 
a000b4ec:	e1d621b4 	ldrh	r2, [r6, #20]                                <== NOT EXECUTED
a000b4f0:	e0842002 	add	r2, r4, r2                                    <== NOT EXECUTED
         /*                                                           
          *  Get the next node before the node is extracted           
          */                                                          
         extract_me = the_object;                                     
         the_object = (Objects_Control *) the_object->Node.next;      
         if ((index >= index_base) &&                                 
a000b4f4:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000b4f8:	2afffff4 	bcs	a000b4d0 <_Objects_Shrink_information+0x70>   <== NOT EXECUTED
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
a000b4fc:	ebfffbc5 	bl	a000a418 <_Chain_Extract>                      <== NOT EXECUTED
         }                                                            
       }                                                              
       while ( the_object );                                          
a000b500:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000b504:	1afffff3 	bne	a000b4d8 <_Objects_Shrink_information+0x78>   <== NOT EXECUTED
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
a000b508:	e5963034 	ldr	r3, [r6, #52]	; 0x34                          <== NOT EXECUTED
a000b50c:	e7930007 	ldr	r0, [r3, r7]                                  <== NOT EXECUTED
a000b510:	eb00070a 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
      information->object_blocks[ block ] = NULL;                     
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
a000b514:	e1d602bc 	ldrh	r0, [r6, #44]	; 0x2c                         <== NOT EXECUTED
a000b518:	e1d631b4 	ldrh	r3, [r6, #20]                                <== NOT EXECUTED
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
a000b51c:	e5961034 	ldr	r1, [r6, #52]	; 0x34                          <== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;                   
a000b520:	e5962030 	ldr	r2, [r6, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
      information->inactive -= information->allocation_size;          
a000b524:	e0633000 	rsb	r3, r3, r0                                    <== NOT EXECUTED
      /*                                                              
       *  Free the memory and reset the structures in the object' information
       */                                                             
                                                                      
      _Workspace_Free( information->object_blocks[ block ] );         
      information->object_blocks[ block ] = NULL;                     
a000b528:	e7815007 	str	r5, [r1, r7]                                  <== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;                   
a000b52c:	e7825007 	str	r5, [r2, r7]                                  <== NOT EXECUTED
                                                                      
      information->inactive -= information->allocation_size;          
a000b530:	e1c632bc 	strh	r3, [r6, #44]	; 0x2c                         <== NOT EXECUTED
                                                                      
      return;                                                         
a000b534:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000b860 <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, uintptr_t size ) {
a000b860:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  bool      extend_ok;                                                
  uintptr_t amount_extended;                                          
                                                                      
  _RTEMS_Lock_allocator();                                            
a000b864:	e59f4040 	ldr	r4, [pc, #64]	; a000b8ac <_Protected_heap_Extend+0x4c><== NOT EXECUTED
bool _Protected_heap_Extend(                                          
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  uintptr_t     size                                                  
)                                                                     
{                                                                     
a000b868:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000b86c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000b870:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
a000b874:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  bool      extend_ok;                                                
  uintptr_t amount_extended;                                          
                                                                      
  _RTEMS_Lock_allocator();                                            
a000b878:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000b87c:	ebfffb8a 	bl	a000a6ac <_API_Mutex_Lock>                     <== NOT EXECUTED
    extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
a000b880:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000b884:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000b888:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
a000b88c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000b890:	eb000ff0 	bl	a000f858 <_Heap_Extend>                        <== NOT EXECUTED
a000b894:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  _RTEMS_Unlock_allocator();                                          
a000b898:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000b89c:	ebfffb9e 	bl	a000a71c <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return extend_ok;                                                   
}                                                                     
a000b8a0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000b8a4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000b8a8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000b584 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) {
a000b584:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  bool    status;                                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a000b588:	e59f402c 	ldr	r4, [pc, #44]	; a000b5bc <_Protected_heap_Free+0x38><== NOT EXECUTED
                                                                      
bool _Protected_heap_Free(                                            
  Heap_Control *the_heap,                                             
  void         *start_address                                         
)                                                                     
{                                                                     
a000b58c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000b590:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  bool    status;                                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a000b594:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000b598:	ebfffb6a 	bl	a000a348 <_API_Mutex_Lock>                     <== NOT EXECUTED
    status = _Heap_Free( the_heap, start_address );                   
a000b59c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000b5a0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000b5a4:	eb000fd8 	bl	a000f50c <_Heap_Free>                          <== NOT EXECUTED
a000b5a8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  _RTEMS_Unlock_allocator();                                          
a000b5ac:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000b5b0:	ebfffb80 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return status;                                                      
}                                                                     
a000b5b4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000b5b8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0010a94 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) {
a0010a94:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  /*                                                                  
   * TBD: _Heap_Get_free_information does not error check or return status.
   */                                                                 
                                                                      
  _RTEMS_Lock_allocator();                                            
a0010a98:	e59f4028 	ldr	r4, [pc, #40]	; a0010ac8 <_Protected_heap_Get_free_information+0x34><== NOT EXECUTED
                                                                      
bool _Protected_heap_Get_free_information(                            
  Heap_Control        *the_heap,                                      
  Heap_Information    *info                                           
)                                                                     
{                                                                     
a0010a9c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0010aa0:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  /*                                                                  
   * TBD: _Heap_Get_free_information does not error check or return status.
   */                                                                 
                                                                      
  _RTEMS_Lock_allocator();                                            
a0010aa4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0010aa8:	ebfff829 	bl	a000eb54 <_API_Mutex_Lock>                     <== NOT EXECUTED
    _Heap_Get_free_information( the_heap, info );                     
a0010aac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010ab0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010ab4:	eb00109b 	bl	a0014d28 <_Heap_Get_free_information>          <== NOT EXECUTED
  _RTEMS_Unlock_allocator();                                          
a0010ab8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0010abc:	ebfff840 	bl	a000ebc4 <_API_Mutex_Unlock>                   <== NOT EXECUTED
                                                                      
  return true;                                                        
}                                                                     
a0010ac0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0010ac4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000bce8 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) {
a000bce8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if ( !the_heap )                                                    
a000bcec:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
                                                                      
bool _Protected_heap_Get_information(                                 
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
)                                                                     
{                                                                     
a000bcf0:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  if ( !the_heap )                                                    
a000bcf4:	0a00000d 	beq	a000bd30 <_Protected_heap_Get_information+0x48><== NOT EXECUTED
    return false;                                                     
                                                                      
  if ( !the_info )                                                    
a000bcf8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000bcfc:	0a000009 	beq	a000bd28 <_Protected_heap_Get_information+0x40><== NOT EXECUTED
    return false;                                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a000bd00:	e59f4030 	ldr	r4, [pc, #48]	; a000bd38 <_Protected_heap_Get_information+0x50><== NOT EXECUTED
a000bd04:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000bd08:	ebfffb7a 	bl	a000aaf8 <_API_Mutex_Lock>                     <== NOT EXECUTED
    _Heap_Get_information( the_heap, the_info );                      
a000bd0c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000bd10:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000bd14:	eb00111c 	bl	a001018c <_Heap_Get_information>               <== NOT EXECUTED
  _RTEMS_Unlock_allocator();                                          
a000bd18:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a000bd1c:	ebfffb91 	bl	a000ab68 <_API_Mutex_Unlock>                   <== NOT EXECUTED
                                                                      
  return true;                                                        
a000bd20:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000bd24:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
{                                                                     
  if ( !the_heap )                                                    
    return false;                                                     
                                                                      
  if ( !the_info )                                                    
    return false;                                                     
a000bd28:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
  _RTEMS_Lock_allocator();                                            
    _Heap_Get_information( the_heap, the_info );                      
  _RTEMS_Unlock_allocator();                                          
                                                                      
  return true;                                                        
}                                                                     
a000bd2c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  Heap_Control            *the_heap,                                  
  Heap_Information_block  *the_info                                   
)                                                                     
{                                                                     
  if ( !the_heap )                                                    
    return false;                                                     
a000bd30:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000bd34:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0016424 <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, uintptr_t size ) {
a0016424:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  Heap_Resize_status status;                                          
  uintptr_t          old_mem_size;                                    
  uintptr_t          avail_mem_size;                                  
                                                                      
  _RTEMS_Lock_allocator();                                            
a0016428:	e59f404c 	ldr	r4, [pc, #76]	; a001647c <_Protected_heap_Resize_block+0x58><== NOT EXECUTED
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  uintptr_t     size                                                  
)                                                                     
{                                                                     
a001642c:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a0016430:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  Heap_Resize_status status;                                          
  uintptr_t          old_mem_size;                                    
  uintptr_t          avail_mem_size;                                  
                                                                      
  _RTEMS_Lock_allocator();                                            
a0016434:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
bool _Protected_heap_Resize_block(                                    
  Heap_Control *the_heap,                                             
  void         *starting_address,                                     
  uintptr_t     size                                                  
)                                                                     
{                                                                     
a0016438:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
a001643c:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  Heap_Resize_status status;                                          
  uintptr_t          old_mem_size;                                    
  uintptr_t          avail_mem_size;                                  
                                                                      
  _RTEMS_Lock_allocator();                                            
a0016440:	ebffcfc0 	bl	a000a348 <_API_Mutex_Lock>                     <== NOT EXECUTED
    status = _Heap_Resize_block(                                      
a0016444:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
a0016448:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a001644c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0016450:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
a0016454:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0016458:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001645c:	eb000007 	bl	a0016480 <_Heap_Resize_block>                  <== NOT EXECUTED
a0016460:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();                                          
a0016464:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0016468:	ebffcfd2 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return (status == HEAP_RESIZE_SUCCESSFUL);                          
}                                                                     
a001646c:	e2750001 	rsbs	r0, r5, #1                                   <== NOT EXECUTED
a0016470:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
a0016474:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a0016478:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a0010b84 <_Protected_heap_Walk>: * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) {
a0010b84:	e59f3054 	ldr	r3, [pc, #84]	; a0010be0 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(                                            
  Heap_Control *the_heap,                                             
  int           source,                                               
  bool          do_dump                                               
)                                                                     
{                                                                     
a0010b88:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   * then it is forbidden to lock a mutex.  But since we are inside   
   * a critical section, it should be safe to walk it unlocked.       
   *                                                                  
   * NOTE: Dispatching is also disabled during initialization.        
   */                                                                 
  if ( !_Thread_Dispatch_disable_level ) {                            
a0010b8c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
bool _Protected_heap_Walk(                                            
  Heap_Control *the_heap,                                             
  int           source,                                               
  bool          do_dump                                               
)                                                                     
{                                                                     
a0010b90:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0010b94:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
   * then it is forbidden to lock a mutex.  But since we are inside   
   * a critical section, it should be safe to walk it unlocked.       
   *                                                                  
   * NOTE: Dispatching is also disabled during initialization.        
   */                                                                 
  if ( !_Thread_Dispatch_disable_level ) {                            
a0010b98:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
bool _Protected_heap_Walk(                                            
  Heap_Control *the_heap,                                             
  int           source,                                               
  bool          do_dump                                               
)                                                                     
{                                                                     
a0010b9c:	e20250ff 	and	r5, r2, #255	; 0xff                           <== NOT EXECUTED
   * then it is forbidden to lock a mutex.  But since we are inside   
   * a critical section, it should be safe to walk it unlocked.       
   *                                                                  
   * NOTE: Dispatching is also disabled during initialization.        
   */                                                                 
  if ( !_Thread_Dispatch_disable_level ) {                            
a0010ba0:	0a000002 	beq	a0010bb0 <_Protected_heap_Walk+0x2c>          <== NOT EXECUTED
    _RTEMS_Lock_allocator();                                          
      status = _Heap_Walk( the_heap, source, do_dump );               
    _RTEMS_Unlock_allocator();                                        
  } else {                                                            
    status = _Heap_Walk( the_heap, source, do_dump );                 
a0010ba4:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
  }                                                                   
  return status;                                                      
}                                                                     
a0010ba8:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
  if ( !_Thread_Dispatch_disable_level ) {                            
    _RTEMS_Lock_allocator();                                          
      status = _Heap_Walk( the_heap, source, do_dump );               
    _RTEMS_Unlock_allocator();                                        
  } else {                                                            
    status = _Heap_Walk( the_heap, source, do_dump );                 
a0010bac:	eafffbf8 	b	a000fb94 <_Heap_Walk>                           <== NOT EXECUTED
   * a critical section, it should be safe to walk it unlocked.       
   *                                                                  
   * NOTE: Dispatching is also disabled during initialization.        
   */                                                                 
  if ( !_Thread_Dispatch_disable_level ) {                            
    _RTEMS_Lock_allocator();                                          
a0010bb0:	e59f402c 	ldr	r4, [pc, #44]	; a0010be4 <_Protected_heap_Walk+0x60><== NOT EXECUTED
a0010bb4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0010bb8:	ebfff7e5 	bl	a000eb54 <_API_Mutex_Lock>                     <== NOT EXECUTED
      status = _Heap_Walk( the_heap, source, do_dump );               
a0010bbc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0010bc0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010bc4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010bc8:	ebfffbf1 	bl	a000fb94 <_Heap_Walk>                          <== NOT EXECUTED
a0010bcc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    _RTEMS_Unlock_allocator();                                        
a0010bd0:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0010bd4:	ebfff7fa 	bl	a000ebc4 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  } else {                                                            
    status = _Heap_Walk( the_heap, source, do_dump );                 
  }                                                                   
  return status;                                                      
}                                                                     
a0010bd8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010bdc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000efb8 <_RTEMS_Tasks_Invoke_task_variable_dtor>: { void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) {
a000efb8:	e59f203c 	ldr	r2, [pc, #60]	; a000effc <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED
)                                                                     
{                                                                     
  void (*dtor)(void *);                                               
  void *value;                                                        
                                                                      
  dtor = tvp->dtor;                                                   
a000efbc:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
                                                                      
void _RTEMS_Tasks_Invoke_task_variable_dtor(                          
  Thread_Control        *the_thread,                                  
  rtems_task_variable_t *tvp                                          
)                                                                     
{                                                                     
a000efc0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  void (*dtor)(void *);                                               
  void *value;                                                        
                                                                      
  dtor = tvp->dtor;                                                   
  if (_Thread_Is_executing(the_thread)) {                             
a000efc4:	e5922004 	ldr	r2, [r2, #4]                                  <== NOT EXECUTED
                                                                      
void _RTEMS_Tasks_Invoke_task_variable_dtor(                          
  Thread_Control        *the_thread,                                  
  rtems_task_variable_t *tvp                                          
)                                                                     
{                                                                     
a000efc8:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  void (*dtor)(void *);                                               
  void *value;                                                        
                                                                      
  dtor = tvp->dtor;                                                   
  if (_Thread_Is_executing(the_thread)) {                             
a000efcc:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
    value = *tvp->ptr;                                                
a000efd0:	05912004 	ldreq	r2, [r1, #4]                                <== NOT EXECUTED
    *tvp->ptr = tvp->gval;                                            
a000efd4:	05911008 	ldreq	r1, [r1, #8]                                <== NOT EXECUTED
  } else {                                                            
    value = tvp->tval;                                                
a000efd8:	1594000c 	ldrne	r0, [r4, #12]                               <== NOT EXECUTED
  void (*dtor)(void *);                                               
  void *value;                                                        
                                                                      
  dtor = tvp->dtor;                                                   
  if (_Thread_Is_executing(the_thread)) {                             
    value = *tvp->ptr;                                                
a000efdc:	05920000 	ldreq	r0, [r2]                                    <== NOT EXECUTED
    *tvp->ptr = tvp->gval;                                            
a000efe0:	05821000 	streq	r1, [r2]                                    <== NOT EXECUTED
  } else {                                                            
    value = tvp->tval;                                                
  }                                                                   
                                                                      
  if ( dtor )                                                         
a000efe4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000efe8:	0a000000 	beq	a000eff0 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x38><== NOT EXECUTED
    (*dtor)(value);                                                   
a000efec:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  _Workspace_Free(tvp);                                               
a000eff0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a000eff4:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( dtor )                                                         
    (*dtor)(value);                                                   
                                                                      
  _Workspace_Free(tvp);                                               
a000eff8:	eafff850 	b	a000d140 <_Workspace_Free>                      <== NOT EXECUTED
                                                                      

a000ee84 <_RTEMS_tasks_Delete_extension>: void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) {
a000ee84:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000ee88:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Free per task variable memory                                   
   */                                                                 
                                                                      
  tvp = deleted->task_variables;                                      
a000ee8c:	e5911100 	ldr	r1, [r1, #256]	; 0x100                        <== NOT EXECUTED
  deleted->task_variables = NULL;                                     
a000ee90:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ee94:	e5853100 	str	r3, [r5, #256]	; 0x100                        <== NOT EXECUTED
  while (tvp) {                                                       
a000ee98:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
a000ee9c:	1a000001 	bne	a000eea8 <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED
a000eea0:	ea000005 	b	a000eebc <_RTEMS_tasks_Delete_extension+0x38>   <== NOT EXECUTED
    next = (rtems_task_variable_t *)tvp->next;                        
    _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );           
    tvp = next;                                                       
a000eea4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  tvp = deleted->task_variables;                                      
  deleted->task_variables = NULL;                                     
  while (tvp) {                                                       
    next = (rtems_task_variable_t *)tvp->next;                        
a000eea8:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
    _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );           
a000eeac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000eeb0:	eb000040 	bl	a000efb8 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
   *  Free per task variable memory                                   
   */                                                                 
                                                                      
  tvp = deleted->task_variables;                                      
  deleted->task_variables = NULL;                                     
  while (tvp) {                                                       
a000eeb4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000eeb8:	1afffff9 	bne	a000eea4 <_RTEMS_tasks_Delete_extension+0x20> <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Free API specific memory                                        
   */                                                                 
                                                                      
  (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
a000eebc:	e59500f4 	ldr	r0, [r5, #244]	; 0xf4                         <== NOT EXECUTED
a000eec0:	ebfff89e 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
  deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;                 
a000eec4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000eec8:	e58530f4 	str	r3, [r5, #244]	; 0xf4                         <== NOT EXECUTED
}                                                                     
a000eecc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0009e50 <_RTEMS_tasks_Initialize_user_tasks_body>: rtems_initialization_tasks_table *user_tasks; /* * Move information into local variables */ user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
a0009e50:	e59f3084 	ldr	r3, [pc, #132]	; a0009edc <_RTEMS_tasks_Initialize_user_tasks_body+0x8c>
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _RTEMS_tasks_Initialize_user_tasks_body( void )                  
{                                                                     
a0009e54:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  rtems_initialization_tasks_table *user_tasks;                       
                                                                      
  /*                                                                  
   *  Move information into local variables                           
   */                                                                 
  user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
a0009e58:	e593402c 	ldr	r4, [r3, #44]	; 0x2c                          
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _RTEMS_tasks_Initialize_user_tasks_body( void )                  
{                                                                     
a0009e5c:	e24dd00c 	sub	sp, sp, #12                                   
                                                                      
  /*                                                                  
   *  Move information into local variables                           
   */                                                                 
  user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
  maximum    = Configuration_RTEMS_API.number_of_initialization_tasks;
a0009e60:	e5936028 	ldr	r6, [r3, #40]	; 0x28                          
                                                                      
  /*                                                                  
   *  Verify that we have a set of user tasks to iterate              
   */                                                                 
  if ( !user_tasks )                                                  
a0009e64:	e3540000 	cmp	r4, #0                                        
a0009e68:	0a000016 	beq	a0009ec8 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
a0009e6c:	e3560000 	cmp	r6, #0                                        
a0009e70:	0a000014 	beq	a0009ec8 <_RTEMS_tasks_Initialize_user_tasks_body+0x78>
a0009e74:	e3a05000 	mov	r5, #0                                        
a0009e78:	e28d7008 	add	r7, sp, #8                                    
    return_value = rtems_task_create(                                 
a0009e7c:	e594c00c 	ldr	ip, [r4, #12]                                 
a0009e80:	e8940005 	ldm	r4, {r0, r2}                                  
a0009e84:	e5941008 	ldr	r1, [r4, #8]                                  
a0009e88:	e5943014 	ldr	r3, [r4, #20]                                 
a0009e8c:	e58dc000 	str	ip, [sp]                                      
a0009e90:	e58d7004 	str	r7, [sp, #4]                                  
a0009e94:	ebffff67 	bl	a0009c38 <rtems_task_create>                   
      user_tasks[ index ].stack_size,                                 
      user_tasks[ index ].mode_set,                                   
      user_tasks[ index ].attribute_set,                              
      &id                                                             
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
a0009e98:	e2502000 	subs	r2, r0, #0                                   
a0009e9c:	1a00000b 	bne	a0009ed0 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
                                                                      
    return_value = rtems_task_start(                                  
a0009ea0:	e5942018 	ldr	r2, [r4, #24]                                 
a0009ea4:	e59d0008 	ldr	r0, [sp, #8]                                  
a0009ea8:	e5941010 	ldr	r1, [r4, #16]                                 
a0009eac:	eb00000b 	bl	a0009ee0 <rtems_task_start>                    
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
a0009eb0:	e2502000 	subs	r2, r0, #0                                   
a0009eb4:	1a000005 	bne	a0009ed0 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
a0009eb8:	e2855001 	add	r5, r5, #1                                    
a0009ebc:	e1560005 	cmp	r6, r5                                        
a0009ec0:	e284401c 	add	r4, r4, #28                                   
a0009ec4:	8affffec 	bhi	a0009e7c <_RTEMS_tasks_Initialize_user_tasks_body+0x2c>
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
  }                                                                   
}                                                                     
a0009ec8:	e28dd00c 	add	sp, sp, #12                                   
a0009ecc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
      id,                                                             
      user_tasks[ index ].entry_point,                                
      user_tasks[ index ].argument                                    
    );                                                                
    if ( !rtems_is_status_successful( return_value ) )                
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
a0009ed0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0009ed4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0009ed8:	eb00039e 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a000edf4 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) {
a000edf4:	e92d4070 	push	{r4, r5, r6, lr}                             
  RTEMS_API_Control *api;                                             
  ASR_Information   *asr;                                             
  rtems_signal_set   signal_set;                                      
  Modes_Control      prev_mode;                                       
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
a000edf8:	e59040f4 	ldr	r4, [r0, #244]	; 0xf4                         
 */                                                                   
                                                                      
void _RTEMS_tasks_Post_switch_extension(                              
  Thread_Control *executing                                           
)                                                                     
{                                                                     
a000edfc:	e24dd004 	sub	sp, sp, #4                                    
  ASR_Information   *asr;                                             
  rtems_signal_set   signal_set;                                      
  Modes_Control      prev_mode;                                       
                                                                      
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  if ( !api )                                                         
a000ee00:	e3540000 	cmp	r4, #0                                        
a000ee04:	0a00001c 	beq	a000ee7c <_RTEMS_tasks_Post_switch_extension+0x88>
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000ee08:	e10f3000 	mrs	r3, CPSR                                      
a000ee0c:	e3832080 	orr	r2, r3, #128	; 0x80                           
a000ee10:	e129f002 	msr	CPSR_fc, r2                                   
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
    signal_set = asr->signals_posted;                                 
    asr->signals_posted = 0;                                          
a000ee14:	e3a02000 	mov	r2, #0                                        
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
    signal_set = asr->signals_posted;                                 
a000ee18:	e5945014 	ldr	r5, [r4, #20]                                 
    asr->signals_posted = 0;                                          
a000ee1c:	e5842014 	str	r2, [r4, #20]                                 
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000ee20:	e129f003 	msr	CPSR_fc, r3                                   
  _ISR_Enable( level );                                               
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
a000ee24:	e3550000 	cmp	r5, #0                                        
a000ee28:	0a000013 	beq	a000ee7c <_RTEMS_tasks_Post_switch_extension+0x88>
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
a000ee2c:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
a000ee30:	e3a01801 	mov	r1, #65536	; 0x10000                          <== NOT EXECUTED
a000ee34:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
a000ee38:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
a000ee3c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
a000ee40:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
a000ee44:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a000ee48:	eb000781 	bl	a0010c54 <rtems_task_mode>                     <== NOT EXECUTED
                                                                      
  (*asr->handler)( signal_set );                                      
a000ee4c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ee50:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a000ee54:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  asr->nest_level -= 1;                                               
a000ee58:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
a000ee5c:	e3a01801 	mov	r1, #65536	; 0x10000                          <== NOT EXECUTED
a000ee60:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
a000ee64:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000ee68:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
a000ee6c:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
a000ee70:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
a000ee74:	e1a0600d 	mov	r6, sp                                        <== NOT EXECUTED
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
a000ee78:	eb000775 	bl	a0010c54 <rtems_task_mode>                     <== NOT EXECUTED
                                                                      
}                                                                     
a000ee7c:	e28dd004 	add	sp, sp, #4                                    
a000ee80:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

a000ed78 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables;
a000ed78:	e5903100 	ldr	r3, [r0, #256]	; 0x100                        <== NOT EXECUTED
  while (tvp) {                                                       
a000ed7c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ed80:	0a000007 	beq	a000eda4 <_RTEMS_tasks_Switch_extension+0x2c> <== NOT EXECUTED
    tvp->tval = *tvp->ptr;                                            
a000ed84:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
    *tvp->ptr = tvp->gval;                                            
a000ed88:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
    tvp->tval = *tvp->ptr;                                            
a000ed8c:	e592c000 	ldr	ip, [r2]                                      <== NOT EXECUTED
a000ed90:	e583c00c 	str	ip, [r3, #12]                                 <== NOT EXECUTED
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
a000ed94:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
    tvp->tval = *tvp->ptr;                                            
    *tvp->ptr = tvp->gval;                                            
a000ed98:	e5820000 	str	r0, [r2]                                      <== NOT EXECUTED
  /*                                                                  
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
a000ed9c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000eda0:	1afffff7 	bne	a000ed84 <_RTEMS_tasks_Switch_extension+0xc>  <== NOT EXECUTED
    tvp->tval = *tvp->ptr;                                            
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
a000eda4:	e5913100 	ldr	r3, [r1, #256]	; 0x100                        <== NOT EXECUTED
  while (tvp) {                                                       
a000eda8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000edac:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    tvp->gval = *tvp->ptr;                                            
a000edb0:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
    *tvp->ptr = tvp->tval;                                            
a000edb4:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
    tvp->gval = *tvp->ptr;                                            
a000edb8:	e5920000 	ldr	r0, [r2]                                      <== NOT EXECUTED
a000edbc:	e5830008 	str	r0, [r3, #8]                                  <== NOT EXECUTED
    *tvp->ptr = tvp->tval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
a000edc0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
    tvp->gval = *tvp->ptr;                                            
    *tvp->ptr = tvp->tval;                                            
a000edc4:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
a000edc8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000edcc:	1afffff7 	bne	a000edb0 <_RTEMS_tasks_Switch_extension+0x38> <== NOT EXECUTED
a000edd0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a990 <_Rate_monotonic_Get_status>: bool _Rate_monotonic_Get_status( Rate_monotonic_Control *the_period, Rate_monotonic_Period_time_t *wall_since_last_period, Thread_CPU_usage_t *cpu_since_last_period ) {
a000a990:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a000a994:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000a998:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control        uptime;                                  
  #endif                                                              
    Thread_Control          *owning_thread = the_period->owner;       
a000a99c:	e5946040 	ldr	r6, [r4, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
a000a9a0:	e28d5010 	add	r5, sp, #16                                   <== NOT EXECUTED
bool _Rate_monotonic_Get_status(                                      
  Rate_monotonic_Control        *the_period,                          
  Rate_monotonic_Period_time_t  *wall_since_last_period,              
  Thread_CPU_usage_t            *cpu_since_last_period                
)                                                                     
{                                                                     
a000a9a4:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
a000a9a8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
bool _Rate_monotonic_Get_status(                                      
  Rate_monotonic_Control        *the_period,                          
  Rate_monotonic_Period_time_t  *wall_since_last_period,              
  Thread_CPU_usage_t            *cpu_since_last_period                
)                                                                     
{                                                                     
a000a9ac:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
a000a9b0:	eb000667 	bl	a000c354 <_TOD_Get_uptime>                     <== NOT EXECUTED
    _Timestamp_Subtract(                                              
a000a9b4:	e284004c 	add	r0, r4, #76	; 0x4c                            <== NOT EXECUTED
a000a9b8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a000a9bc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000a9c0:	eb000f7f 	bl	a000e7c4 <_Timespec_Subtract>                  <== NOT EXECUTED
  #endif                                                              
                                                                      
  /*                                                                  
   *  Determine cpu usage since period initiated.                     
   */                                                                 
  used = owning_thread->cpu_time_used;                                
a000a9c4:	e2863084 	add	r3, r6, #132	; 0x84                           <== NOT EXECUTED
a000a9c8:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a000a9cc:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a000a9d0:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
a000a9d4:	e59f306c 	ldr	r3, [pc, #108]	; a000aa48 <_Rate_monotonic_Get_status+0xb8><== NOT EXECUTED
a000a9d8:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000a9dc:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
      if (used < the_period->cpu_usage_period_initiated)              
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
a000a9e0:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
   *  Determine cpu usage since period initiated.                     
   */                                                                 
  used = owning_thread->cpu_time_used;                                
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
a000a9e4:	0a000001 	beq	a000a9f0 <_Rate_monotonic_Get_status+0x60>    <== NOT EXECUTED
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
}                                                                     
a000a9e8:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a000a9ec:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    if (owning_thread == _Thread_Executing) {                         
                                                                      
      Thread_CPU_usage_t ran;                                         
                                                                      
      /* How much time time since last context switch */              
      _Timestamp_Subtract(                                            
a000a9f0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000a9f4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000a9f8:	e59f004c 	ldr	r0, [pc, #76]	; a000aa4c <_Rate_monotonic_Get_status+0xbc><== NOT EXECUTED
        &_Thread_Time_of_last_context_switch, &uptime, &ran           
      );                                                              
                                                                      
      /* cpu usage += ran */                                          
      _Timestamp_Add_to( &used, &ran );                               
a000a9fc:	e28d5008 	add	r5, sp, #8                                    <== NOT EXECUTED
    if (owning_thread == _Thread_Executing) {                         
                                                                      
      Thread_CPU_usage_t ran;                                         
                                                                      
      /* How much time time since last context switch */              
      _Timestamp_Subtract(                                            
a000aa00:	eb000f6f 	bl	a000e7c4 <_Timespec_Subtract>                  <== NOT EXECUTED
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
a000aa04:	e2844044 	add	r4, r4, #68	; 0x44                            <== NOT EXECUTED
      _Timestamp_Subtract(                                            
        &_Thread_Time_of_last_context_switch, &uptime, &ran           
      );                                                              
                                                                      
      /* cpu usage += ran */                                          
      _Timestamp_Add_to( &used, &ran );                               
a000aa08:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000aa0c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000aa10:	eb000f1a 	bl	a000e680 <_Timespec_Add_to>                    <== NOT EXECUTED
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
a000aa14:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000aa18:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000aa1c:	eb000f5a 	bl	a000e78c <_Timespec_Less_than>                 <== NOT EXECUTED
a000aa20:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    if (owning_thread == _Thread_Executing) {                         
                                                                      
      Thread_CPU_usage_t ran;                                         
                                                                      
      /* How much time time since last context switch */              
      _Timestamp_Subtract(                                            
a000aa24:	e1a0600d 	mov	r6, sp                                        <== NOT EXECUTED
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
        return false;                                                 
a000aa28:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
a000aa2c:	1affffed 	bne	a000a9e8 <_Rate_monotonic_Get_status+0x58>    <== NOT EXECUTED
        return false;                                                 
                                                                      
       /* used = current cpu usage - cpu usage at start of period */  
      _Timestamp_Subtract(                                            
a000aa30:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000aa34:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000aa38:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a000aa3c:	eb000f60 	bl	a000e7c4 <_Timespec_Subtract>                  <== NOT EXECUTED
      if (used < the_period->cpu_usage_period_initiated)              
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
a000aa40:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000aa44:	eaffffe7 	b	a000a9e8 <_Rate_monotonic_Get_status+0x58>      <== NOT EXECUTED
                                                                      

a000aa50 <_Rate_monotonic_Initiate_statistics>: } void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) {
a000aa50:	e92d4870 	push	{r4, r5, r6, fp, lr}                         <== NOT EXECUTED
a000aa54:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
   *  If using nanosecond statistics, we need to obtain the uptime.   
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control  uptime;                                        
                                                                      
    _TOD_Get_uptime( &uptime );                                       
a000aa58:	e28d6008 	add	r6, sp, #8                                    <== NOT EXECUTED
}                                                                     
                                                                      
void _Rate_monotonic_Initiate_statistics(                             
  Rate_monotonic_Control *the_period                                  
)                                                                     
{                                                                     
a000aa5c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   *  If using nanosecond statistics, we need to obtain the uptime.   
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control  uptime;                                        
                                                                      
    _TOD_Get_uptime( &uptime );                                       
a000aa60:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
void _Rate_monotonic_Initiate_statistics(                             
  Rate_monotonic_Control *the_period                                  
)                                                                     
{                                                                     
  Thread_Control *owning_thread = the_period->owner;                  
a000aa64:	e5945040 	ldr	r5, [r4, #64]	; 0x40                          <== NOT EXECUTED
   *  If using nanosecond statistics, we need to obtain the uptime.   
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control  uptime;                                        
                                                                      
    _TOD_Get_uptime( &uptime );                                       
a000aa68:	eb000639 	bl	a000c354 <_TOD_Get_uptime>                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Set the starting point and the CPU time used for the statistics.
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    the_period->time_period_initiated = uptime;                       
a000aa6c:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
a000aa70:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  #else                                                               
    the_period->time_period_initiated = _Watchdog_Ticks_since_boot;   
  #endif                                                              
                                                                      
  the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used;
a000aa74:	e2852084 	add	r2, r5, #132	; 0x84                           <== NOT EXECUTED
a000aa78:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
   *  routine is invoked from rtems_rate_monotonic_period, the owner will
   *  be the executing thread.  When this routine is invoked from     
   *  _Rate_monotonic_Timeout, it will not.                           
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
a000aa7c:	e59f3044 	ldr	r3, [pc, #68]	; a000aac8 <_Rate_monotonic_Initiate_statistics+0x78><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Set the starting point and the CPU time used for the statistics.
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    the_period->time_period_initiated = uptime;                       
a000aa80:	e584b04c 	str	fp, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a000aa84:	e584c050 	str	ip, [r4, #80]	; 0x50                          <== NOT EXECUTED
   *  routine is invoked from rtems_rate_monotonic_period, the owner will
   *  be the executing thread.  When this routine is invoked from     
   *  _Rate_monotonic_Timeout, it will not.                           
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
a000aa88:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
    the_period->time_period_initiated = uptime;                       
  #else                                                               
    the_period->time_period_initiated = _Watchdog_Ticks_since_boot;   
  #endif                                                              
                                                                      
  the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used;
a000aa8c:	e5841044 	str	r1, [r4, #68]	; 0x44                          <== NOT EXECUTED
a000aa90:	e5842048 	str	r2, [r4, #72]	; 0x48                          <== NOT EXECUTED
   *  routine is invoked from rtems_rate_monotonic_period, the owner will
   *  be the executing thread.  When this routine is invoked from     
   *  _Rate_monotonic_Timeout, it will not.                           
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
a000aa94:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a000aa98:	0a000001 	beq	a000aaa4 <_Rate_monotonic_Initiate_statistics+0x54><== NOT EXECUTED
      );                                                              
                                                                      
      _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
    }                                                                 
  #endif                                                              
}                                                                     
a000aa9c:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a000aaa0:	e8bd8870 	pop	{r4, r5, r6, fp, pc}                          <== NOT EXECUTED
                                                                      
      /*                                                              
       *  Adjust the CPU time used to account for the time since last 
       *  context switch.                                             
       */                                                             
      _Timespec_Subtract(                                             
a000aaa4:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000aaa8:	e59f001c 	ldr	r0, [pc, #28]	; a000aacc <_Rate_monotonic_Initiate_statistics+0x7c><== NOT EXECUTED
a000aaac:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000aab0:	eb000f43 	bl	a000e7c4 <_Timespec_Subtract>                  <== NOT EXECUTED
        &_Thread_Time_of_last_context_switch, &uptime, &ran           
      );                                                              
                                                                      
      _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
a000aab4:	e2840044 	add	r0, r4, #68	; 0x44                            <== NOT EXECUTED
a000aab8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
      /*                                                              
       *  Adjust the CPU time used to account for the time since last 
       *  context switch.                                             
       */                                                             
      _Timespec_Subtract(                                             
        &_Thread_Time_of_last_context_switch, &uptime, &ran           
a000aabc:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
      );                                                              
                                                                      
      _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
a000aac0:	eb000eee 	bl	a000e680 <_Timespec_Add_to>                    <== NOT EXECUTED
a000aac4:	eafffff4 	b	a000aa9c <_Rate_monotonic_Initiate_statistics+0x4c><== NOT EXECUTED
                                                                      

a000b054 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
a000b054:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000b058:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000b05c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000b060:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000b064:	e59f0094 	ldr	r0, [pc, #148]	; a000b100 <_Rate_monotonic_Timeout+0xac><== NOT EXECUTED
a000b068:	eb000791 	bl	a000ceb4 <_Objects_Get>                        <== NOT EXECUTED
  /*                                                                  
   *  When we get here, the Timer is already off the chain so we do not
   *  have to worry about that -- hence no _Watchdog_Remove().        
   */                                                                 
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a000b06c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000b070:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000b074:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b078:	1a000010 	bne	a000b0c0 <_Rate_monotonic_Timeout+0x6c>       <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
a000b07c:	e5900040 	ldr	r0, [r0, #64]	; 0x40                          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (             
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_FOR_PERIOD);                   
a000b080:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
a000b084:	e3130901 	tst	r3, #16384	; 0x4000                           <== NOT EXECUTED
a000b088:	0a000003 	beq	a000b09c <_Rate_monotonic_Timeout+0x48>       <== NOT EXECUTED
a000b08c:	e5902020 	ldr	r2, [r0, #32]                                 <== NOT EXECUTED
a000b090:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a000b094:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000b098:	0a000014 	beq	a000b0f0 <_Rate_monotonic_Timeout+0x9c>       <== NOT EXECUTED
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
a000b09c:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
a000b0a0:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
a000b0a4:	13a03004 	movne	r3, #4                                      <== NOT EXECUTED
a000b0a8:	15843038 	strne	r3, [r4, #56]	; 0x38                        <== NOT EXECUTED
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
a000b0ac:	0a000005 	beq	a000b0c8 <_Rate_monotonic_Timeout+0x74>       <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
a000b0b0:	e59f304c 	ldr	r3, [pc, #76]	; a000b104 <_Rate_monotonic_Timeout+0xb0><== NOT EXECUTED
a000b0b4:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000b0b8:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a000b0bc:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
}                                                                     
a000b0c0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000b0c4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
a000b0c8:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
a000b0cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
a000b0d0:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
a000b0d4:	ebfffe5d 	bl	a000aa50 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000b0d8:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000b0dc:	e59f0024 	ldr	r0, [pc, #36]	; a000b108 <_Rate_monotonic_Timeout+0xb4><== NOT EXECUTED
a000b0e0:	e2841010 	add	r1, r4, #16                                   <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000b0e4:	e584301c 	str	r3, [r4, #28]                                 <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000b0e8:	eb000e78 	bl	a000ead0 <_Watchdog_Insert>                    <== NOT EXECUTED
a000b0ec:	eaffffef 	b	a000b0b0 <_Rate_monotonic_Timeout+0x5c>         <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a000b0f0:	e59f1014 	ldr	r1, [pc, #20]	; a000b10c <_Rate_monotonic_Timeout+0xb8><== NOT EXECUTED
a000b0f4:	eb0009e3 	bl	a000d888 <_Thread_Clear_state>                 <== NOT EXECUTED
      the_thread = the_period->owner;                                 
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
            the_thread->Wait.id == the_period->Object.id ) {          
        _Thread_Unblock( the_thread );                                
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
a000b0f8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b0fc:	eafffff4 	b	a000b0d4 <_Rate_monotonic_Timeout+0x80>         <== NOT EXECUTED
                                                                      

a000aad0 <_Rate_monotonic_Update_statistics>: /* * Update the counts. */ stats = &the_period->Statistics; stats->count++;
a000aad0:	e5903054 	ldr	r3, [r0, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
a000aad4:	e5902038 	ldr	r2, [r0, #56]	; 0x38                          <== NOT EXECUTED
}                                                                     
                                                                      
void _Rate_monotonic_Update_statistics(                               
  Rate_monotonic_Control    *the_period                               
)                                                                     
{                                                                     
a000aad8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
a000aadc:	e3520004 	cmp	r2, #4                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
a000aae0:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000aae4:	e5803054 	str	r3, [r0, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
    stats->missed_count++;                                            
a000aae8:	05903058 	ldreq	r3, [r0, #88]	; 0x58                        <== NOT EXECUTED
}                                                                     
                                                                      
void _Rate_monotonic_Update_statistics(                               
  Rate_monotonic_Control    *the_period                               
)                                                                     
{                                                                     
a000aaec:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
a000aaf0:	e28d6008 	add	r6, sp, #8                                    <== NOT EXECUTED
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
    stats->missed_count++;                                            
a000aaf4:	02833001 	addeq	r3, r3, #1                                  <== NOT EXECUTED
a000aaf8:	05803058 	streq	r3, [r0, #88]	; 0x58                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
a000aafc:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ab00:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
}                                                                     
                                                                      
void _Rate_monotonic_Update_statistics(                               
  Rate_monotonic_Control    *the_period                               
)                                                                     
{                                                                     
a000ab04:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    stats->missed_count++;                                            
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
a000ab08:	ebffffa0 	bl	a000a990 <_Rate_monotonic_Get_status>          <== NOT EXECUTED
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
  if (!valid_status)                                                  
a000ab0c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
a000ab10:	e1a0500d 	mov	r5, sp                                        <== NOT EXECUTED
  if (!valid_status)                                                  
a000ab14:	1a000001 	bne	a000ab20 <_Rate_monotonic_Update_statistics+0x50><== NOT EXECUTED
      stats->min_wall_time = since_last_period;                       
                                                                      
    if ( since_last_period > stats->max_wall_time )                   
      stats->max_wall_time = since_last_period;                       
  #endif                                                              
}                                                                     
a000ab18:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a000ab1c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Update CPU time                                                 
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_cpu_time, &executed );           
a000ab20:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000ab24:	e284006c 	add	r0, r4, #108	; 0x6c                           <== NOT EXECUTED
a000ab28:	eb000ed4 	bl	a000e680 <_Timespec_Add_to>                    <== NOT EXECUTED
                                                                      
    if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )    
a000ab2c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000ab30:	e284105c 	add	r1, r4, #92	; 0x5c                            <== NOT EXECUTED
a000ab34:	eb000f14 	bl	a000e78c <_Timespec_Less_than>                 <== NOT EXECUTED
a000ab38:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      stats->min_cpu_time = executed;                                 
a000ab3c:	128d3008 	addne	r3, sp, #8                                  <== NOT EXECUTED
a000ab40:	1893000c 	ldmne	r3, {r2, r3}                                <== NOT EXECUTED
a000ab44:	1584205c 	strne	r2, [r4, #92]	; 0x5c                        <== NOT EXECUTED
a000ab48:	15843060 	strne	r3, [r4, #96]	; 0x60                        <== NOT EXECUTED
                                                                      
    if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 
a000ab4c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000ab50:	e2841064 	add	r1, r4, #100	; 0x64                           <== NOT EXECUTED
a000ab54:	eb000efe 	bl	a000e754 <_Timespec_Greater_than>              <== NOT EXECUTED
a000ab58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      stats->max_cpu_time = executed;                                 
a000ab5c:	128d3008 	addne	r3, sp, #8                                  <== NOT EXECUTED
a000ab60:	1893000c 	ldmne	r3, {r2, r3}                                <== NOT EXECUTED
a000ab64:	15842064 	strne	r2, [r4, #100]	; 0x64                       <== NOT EXECUTED
a000ab68:	15843068 	strne	r3, [r4, #104]	; 0x68                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Update Wall time                                                
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
a000ab6c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ab70:	e2840084 	add	r0, r4, #132	; 0x84                           <== NOT EXECUTED
a000ab74:	eb000ec1 	bl	a000e680 <_Timespec_Add_to>                    <== NOT EXECUTED
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
a000ab78:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000ab7c:	e2841074 	add	r1, r4, #116	; 0x74                           <== NOT EXECUTED
a000ab80:	eb000f01 	bl	a000e78c <_Timespec_Less_than>                 <== NOT EXECUTED
a000ab84:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ab88:	1a000007 	bne	a000abac <_Rate_monotonic_Update_statistics+0xdc><== NOT EXECUTED
      stats->min_wall_time = since_last_period;                       
                                                                      
    if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
a000ab8c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000ab90:	e284107c 	add	r1, r4, #124	; 0x7c                           <== NOT EXECUTED
a000ab94:	eb000eee 	bl	a000e754 <_Timespec_Greater_than>              <== NOT EXECUTED
a000ab98:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      stats->max_wall_time = since_last_period;                       
a000ab9c:	189d000c 	ldmne	sp, {r2, r3}                                <== NOT EXECUTED
a000aba0:	1584207c 	strne	r2, [r4, #124]	; 0x7c                       <== NOT EXECUTED
a000aba4:	15843080 	strne	r3, [r4, #128]	; 0x80                       <== NOT EXECUTED
a000aba8:	eaffffda 	b	a000ab18 <_Rate_monotonic_Update_statistics+0x48><== NOT EXECUTED
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
      stats->min_wall_time = since_last_period;                       
a000abac:	e89d000c 	ldm	sp, {r2, r3}                                  <== NOT EXECUTED
a000abb0:	e5842074 	str	r2, [r4, #116]	; 0x74                         <== NOT EXECUTED
a000abb4:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
a000abb8:	eafffff3 	b	a000ab8c <_Rate_monotonic_Update_statistics+0xbc><== NOT EXECUTED
                                                                      

a00209c8 <_Region_Process_queue>:
a00209c8:	e59f3084 	ldr	r3, [pc, #132]	; a0020a54 <_Region_Process_queue+0x8c><== NOT EXECUTED
 */                                                                   
                                                                      
void _Region_Process_queue(                                           
  Region_Control *the_region                                          
)                                                                     
{                                                                     
a00209cc:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a00209d0:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a00209d4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a00209d8:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a00209dc:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
   *  NOTE: Be sure to disable dispatching before unlocking the mutex 
   *        since we do not want to open a window where a context     
   *        switch could occur.                                       
   */                                                                 
  _Thread_Disable_dispatch();                                         
  _RTEMS_Unlock_allocator();                                          
a00209e0:	e59f3070 	ldr	r3, [pc, #112]	; a0020a58 <_Region_Process_queue+0x90><== NOT EXECUTED
a00209e4:	e2856010 	add	r6, r5, #16                                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (                 
  Region_Control *the_region,                                         
  uintptr_t       size                                                
)                                                                     
{                                                                     
  return _Heap_Allocate( &the_region->Memory, size );                 
a00209e8:	e2857068 	add	r7, r5, #104	; 0x68                           <== NOT EXECUTED
a00209ec:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a00209f0:	ebffe92e 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
a00209f4:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
a00209f8:	ea00000c 	b	a0020a30 <_Region_Process_queue+0x68>           <== NOT EXECUTED
a00209fc:	e5941024 	ldr	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
a0020a00:	ebffebc7 	bl	a001b924 <_Heap_Allocate_aligned_with_boundary><== NOT EXECUTED
    the_segment = (void **) _Region_Allocate_segment(                 
      the_region,                                                     
      the_thread->Wait.count                                          
    );                                                                
                                                                      
    if ( the_segment == NULL )                                        
a0020a04:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a0020a08:	0a00000f 	beq	a0020a4c <_Region_Process_queue+0x84>         <== NOT EXECUTED
      break;                                                          
                                                                      
    *(void **)the_thread->Wait.return_argument = the_segment;         
    the_region->number_of_used_blocks += 1;                           
a0020a0c:	e5952064 	ldr	r2, [r5, #100]	; 0x64                         <== NOT EXECUTED
    );                                                                
                                                                      
    if ( the_segment == NULL )                                        
      break;                                                          
                                                                      
    *(void **)the_thread->Wait.return_argument = the_segment;         
a0020a10:	e5941028 	ldr	r1, [r4, #40]	; 0x28                          <== NOT EXECUTED
    the_region->number_of_used_blocks += 1;                           
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );     
a0020a14:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
                                                                      
    if ( the_segment == NULL )                                        
      break;                                                          
                                                                      
    *(void **)the_thread->Wait.return_argument = the_segment;         
    the_region->number_of_used_blocks += 1;                           
a0020a18:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    );                                                                
                                                                      
    if ( the_segment == NULL )                                        
      break;                                                          
                                                                      
    *(void **)the_thread->Wait.return_argument = the_segment;         
a0020a1c:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
    the_region->number_of_used_blocks += 1;                           
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );     
a0020a20:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
                                                                      
    if ( the_segment == NULL )                                        
      break;                                                          
                                                                      
    *(void **)the_thread->Wait.return_argument = the_segment;         
    the_region->number_of_used_blocks += 1;                           
a0020a24:	e5852064 	str	r2, [r5, #100]	; 0x64                         <== NOT EXECUTED
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );     
a0020a28:	eb00019b 	bl	a002109c <_Thread_queue_Extract>               <== NOT EXECUTED
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;                  
a0020a2c:	e5848034 	str	r8, [r4, #52]	; 0x34                          <== NOT EXECUTED
  /*                                                                  
   *  NOTE: The following loop is O(n) where n is the number of       
   *        threads whose memory request is satisfied.                
   */                                                                 
  for ( ; ; ) {                                                       
    the_thread = _Thread_queue_First( &the_region->Wait_queue );      
a0020a30:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0020a34:	eb0001da 	bl	a00211a4 <_Thread_queue_First>                 <== NOT EXECUTED
a0020a38:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
                                                                      
    if ( the_thread == NULL )                                         
a0020a3c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0020a40:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
a0020a44:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0020a48:	1affffeb 	bne	a00209fc <_Region_Process_queue+0x34>         <== NOT EXECUTED
    the_region->number_of_used_blocks += 1;                           
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );     
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;                  
  }                                                                   
  _Thread_Enable_dispatch();                                          
}                                                                     
a0020a4c:	e8bd41f0 	pop	{r4, r5, r6, r7, r8, lr}                      <== NOT EXECUTED
    *(void **)the_thread->Wait.return_argument = the_segment;         
    the_region->number_of_used_blocks += 1;                           
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );     
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;                  
  }                                                                   
  _Thread_Enable_dispatch();                                          
a0020a50:	eafff3ca 	b	a001d980 <_Thread_Enable_dispatch>              <== NOT EXECUTED
                                                                      

a000b5f8 <_Scheduler_priority_Block>: ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
a000b5f8:	e590208c 	ldr	r2, [r0, #140]	; 0x8c                         <== NOT EXECUTED
#include <rtems/score/thread.h>                                       
                                                                      
void _Scheduler_priority_Block(                                       
  Thread_Control   *the_thread                                        
)                                                                     
{                                                                     
a000b5fc:	e92d0030 	push	{r4, r5}                                     <== NOT EXECUTED
  ready      = sched_info->ready_chain;                               
a000b600:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  if ( _Chain_Has_only_one_node( ready ) ) {                          
a000b604:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a000b608:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
a000b60c:	e15c0001 	cmp	ip, r1                                        <== NOT EXECUTED
a000b610:	0a00000d 	beq	a000b64c <_Scheduler_priority_Block+0x54>     <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a000b614:	e890000c 	ldm	r0, {r2, r3}                                  <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000b618:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000b61c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (                           
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
a000b620:	e59f30dc 	ldr	r3, [pc, #220]	; a000b704 <_Scheduler_priority_Block+0x10c><== NOT EXECUTED
  _Scheduler_priority_Ready_queue_extract( the_thread );              
                                                                      
  /* TODO: flash critical section? */                                 
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
a000b624:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
a000b628:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
a000b62c:	0a000018 	beq	a000b694 <_Scheduler_priority_Block+0x9c>     <== NOT EXECUTED
     _Scheduler_priority_Schedule_body();                             
                                                                      
  if ( _Thread_Is_executing( the_thread ) )                           
a000b630:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000b634:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    _Thread_Dispatch_necessary = true;                                
a000b638:	059f30c4 	ldreq	r3, [pc, #196]	; a000b704 <_Scheduler_priority_Block+0x10c><== NOT EXECUTED
a000b63c:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
a000b640:	05c32010 	strbeq	r2, [r3, #16]                              <== NOT EXECUTED
                                                                      
}                                                                     
a000b644:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
a000b648:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
a000b64c:	e5921004 	ldr	r1, [r2, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000b650:	e283c004 	add	ip, r3, #4                                    <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
a000b654:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
  head->previous = NULL;                                              
a000b658:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a000b65c:	e583c004 	str	ip, [r3, #4]                                  <== NOT EXECUTED
  tail->previous = head;                                              
a000b660:	e5833008 	str	r3, [r3, #8]                                  <== NOT EXECUTED
a000b664:	e1d1c0b0 	ldrh	ip, [r1]                                     <== NOT EXECUTED
a000b668:	e1d230be 	ldrh	r3, [r2, #14]                                <== NOT EXECUTED
a000b66c:	e00c3003 	and	r3, ip, r3                                    <== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )                                
a000b670:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
a000b674:	e1c130b0 	strh	r3, [r1]                                     <== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )                                
a000b678:	1affffe8 	bne	a000b620 <_Scheduler_priority_Block+0x28>     <== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;         
a000b67c:	e59f3084 	ldr	r3, [pc, #132]	; a000b708 <_Scheduler_priority_Block+0x110><== NOT EXECUTED
a000b680:	e1d220bc 	ldrh	r2, [r2, #12]                                <== NOT EXECUTED
a000b684:	e1d310b0 	ldrh	r1, [r3]                                     <== NOT EXECUTED
a000b688:	e0012002 	and	r2, r1, r2                                    <== NOT EXECUTED
a000b68c:	e1c320b0 	strh	r2, [r3]                                     <== NOT EXECUTED
a000b690:	eaffffe2 	b	a000b620 <_Scheduler_priority_Block+0x28>       <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
a000b694:	e59f206c 	ldr	r2, [pc, #108]	; a000b708 <_Scheduler_priority_Block+0x110><== NOT EXECUTED
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
a000b698:	e59f106c 	ldr	r1, [pc, #108]	; a000b70c <_Scheduler_priority_Block+0x114><== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
a000b69c:	e59f506c 	ldr	r5, [pc, #108]	; a000b710 <_Scheduler_priority_Block+0x118><== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
a000b6a0:	e1d220b0 	ldrh	r2, [r2]                                     <== NOT EXECUTED
a000b6a4:	e591c000 	ldr	ip, [r1]                                      <== NOT EXECUTED
a000b6a8:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
a000b6ac:	e35208ff 	cmp	r2, #16711680	; 0xff0000                      <== NOT EXECUTED
a000b6b0:	959f105c 	ldrls	r1, [pc, #92]	; a000b714 <_Scheduler_priority_Block+0x11c><== NOT EXECUTED
a000b6b4:	859f1058 	ldrhi	r1, [pc, #88]	; a000b714 <_Scheduler_priority_Block+0x11c><== NOT EXECUTED
a000b6b8:	97d12822 	ldrbls	r2, [r1, r2, lsr #16]                      <== NOT EXECUTED
a000b6bc:	87d12c22 	ldrbhi	r2, [r1, r2, lsr #24]                      <== NOT EXECUTED
a000b6c0:	92822008 	addls	r2, r2, #8                                  <== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
a000b6c4:	e1a04082 	lsl	r4, r2, #1                                    <== NOT EXECUTED
a000b6c8:	e19540b4 	ldrh	r4, [r5, r4]                                 <== NOT EXECUTED
a000b6cc:	e35400ff 	cmp	r4, #255	; 0xff                               <== NOT EXECUTED
a000b6d0:	97d11004 	ldrbls	r1, [r1, r4]                               <== NOT EXECUTED
a000b6d4:	87d11424 	ldrbhi	r1, [r1, r4, lsr #8]                       <== NOT EXECUTED
a000b6d8:	92811008 	addls	r1, r1, #8                                  <== NOT EXECUTED
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
a000b6dc:	e0812202 	add	r2, r1, r2, lsl #4                            <== NOT EXECUTED
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
a000b6e0:	e3a0100c 	mov	r1, #12                                       <== NOT EXECUTED
a000b6e4:	e0010192 	mul	r1, r2, r1                                    <== NOT EXECUTED
a000b6e8:	e79c2001 	ldr	r2, [ip, r1]                                  <== NOT EXECUTED
a000b6ec:	e08c1001 	add	r1, ip, r1                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a000b6f0:	e2811004 	add	r1, r1, #4                                    <== NOT EXECUTED
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
a000b6f4:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
a000b6f8:	03a02000 	moveq	r2, #0                                      <== NOT EXECUTED
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
a000b6fc:	e5832008 	str	r2, [r3, #8]                                  <== NOT EXECUTED
a000b700:	eaffffca 	b	a000b630 <_Scheduler_priority_Block+0x38>       <== NOT EXECUTED
                                                                      

a000b76c <_Scheduler_priority_Enqueue>: ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
a000b76c:	e590308c 	ldr	r3, [r0, #140]	; 0x8c                         <== NOT EXECUTED
#include <rtems/score/schedulerpriority.h>                            
                                                                      
void _Scheduler_priority_Enqueue(                                     
  Thread_Control      *the_thread                                     
)                                                                     
{                                                                     
a000b770:	e92d0070 	push	{r4, r5, r6}                                 <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b774:	e593c004 	ldr	ip, [r3, #4]                                  <== NOT EXECUTED
a000b778:	e1d350ba 	ldrh	r5, [r3, #10]                                <== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b77c:	e59f103c 	ldr	r1, [pc, #60]	; a000b7c0 <_Scheduler_priority_Enqueue+0x54><== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b780:	e1dc60b0 	ldrh	r6, [ip]                                     <== NOT EXECUTED
  ready      = sched_info->ready_chain;                               
a000b784:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000b788:	e1865005 	orr	r5, r6, r5                                    <== NOT EXECUTED
a000b78c:	e1cc50b0 	strh	r5, [ip]                                     <== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b790:	e1d3c0b8 	ldrh	ip, [r3, #8]                                 <== NOT EXECUTED
a000b794:	e1d150b0 	ldrh	r5, [r1]                                     <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a000b798:	e5923008 	ldr	r3, [r2, #8]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000b79c:	e2824004 	add	r4, r2, #4                                    <== NOT EXECUTED
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a000b7a0:	e5820008 	str	r0, [r2, #8]                                  <== NOT EXECUTED
a000b7a4:	e185200c 	orr	r2, r5, ip                                    <== NOT EXECUTED
a000b7a8:	e1c120b0 	strh	r2, [r1]                                     <== NOT EXECUTED
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
a000b7ac:	e5803004 	str	r3, [r0, #4]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a000b7b0:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a000b7b4:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
   _Scheduler_priority_Ready_queue_enqueue( the_thread );             
}                                                                     
a000b7b8:	e8bd0070 	pop	{r4, r5, r6}                                  <== NOT EXECUTED
a000b7bc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b718 <_Scheduler_priority_Enqueue_first>: ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
a000b718:	e590308c 	ldr	r3, [r0, #140]	; 0x8c                         <== NOT EXECUTED
#include <rtems/score/schedulerpriority.h>                            
                                                                      
void _Scheduler_priority_Enqueue_first(                               
  Thread_Control      *the_thread                                     
)                                                                     
{                                                                     
a000b71c:	e92d0030 	push	{r4, r5}                                     <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b720:	e593c004 	ldr	ip, [r3, #4]                                  <== NOT EXECUTED
a000b724:	e1d340ba 	ldrh	r4, [r3, #10]                                <== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b728:	e59f1038 	ldr	r1, [pc, #56]	; a000b768 <_Scheduler_priority_Enqueue_first+0x50><== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b72c:	e1dc50b0 	ldrh	r5, [ip]                                     <== NOT EXECUTED
  ready      = sched_info->ready_chain;                               
                                                                      
  _Priority_bit_map_Add( &sched_info->Priority_map );                 
                                                                      
  _Chain_Prepend_unprotected(                                         
a000b730:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000b734:	e1854004 	orr	r4, r5, r4                                    <== NOT EXECUTED
a000b738:	e1cc40b0 	strh	r4, [ip]                                     <== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b73c:	e1d3c0b8 	ldrh	ip, [r3, #8]                                 <== NOT EXECUTED
a000b740:	e1d140b0 	ldrh	r4, [r1]                                     <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a000b744:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a000b748:	e5802004 	str	r2, [r0, #4]                                  <== NOT EXECUTED
a000b74c:	e184c00c 	orr	ip, r4, ip                                    <== NOT EXECUTED
a000b750:	e1c1c0b0 	strh	ip, [r1]                                     <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a000b754:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000b758:	e5820000 	str	r0, [r2]                                      <== NOT EXECUTED
  the_node->next        = before_node;                                
a000b75c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  _Scheduler_priority_Ready_queue_enqueue_first( the_thread );        
}                                                                     
a000b760:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
a000b764:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b7c4 <_Scheduler_priority_Extract>: ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
a000b7c4:	e590208c 	ldr	r2, [r0, #140]	; 0x8c                         <== NOT EXECUTED
  ready      = sched_info->ready_chain;                               
a000b7c8:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  if ( _Chain_Has_only_one_node( ready ) ) {                          
a000b7cc:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a000b7d0:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
a000b7d4:	e15c0001 	cmp	ip, r1                                        <== NOT EXECUTED
a000b7d8:	0a000003 	beq	a000b7ec <_Scheduler_priority_Extract+0x28>   <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a000b7dc:	e890000c 	ldm	r0, {r2, r3}                                  <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000b7e0:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000b7e4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
a000b7e8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
a000b7ec:	e5921004 	ldr	r1, [r2, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000b7f0:	e2830004 	add	r0, r3, #4                                    <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
a000b7f4:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
  head->previous = NULL;                                              
a000b7f8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000b7fc:	e9830009 	stmib	r3, {r0, r3}                                <== NOT EXECUTED
a000b800:	e1d100b0 	ldrh	r0, [r1]                                     <== NOT EXECUTED
a000b804:	e1d230be 	ldrh	r3, [r2, #14]                                <== NOT EXECUTED
a000b808:	e0003003 	and	r3, r0, r3                                    <== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )                                
a000b80c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (                  
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor &= the_priority_map->block_minor;          
a000b810:	e1c130b0 	strh	r3, [r1]                                     <== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )                                
    _Priority_Major_bit_map &= the_priority_map->block_major;         
a000b814:	059f3010 	ldreq	r3, [pc, #16]	; a000b82c <_Scheduler_priority_Extract+0x68><== NOT EXECUTED
a000b818:	01d220bc 	ldrheq	r2, [r2, #12]                              <== NOT EXECUTED
a000b81c:	01d310b0 	ldrheq	r1, [r3]                                   <== NOT EXECUTED
a000b820:	00012002 	andeq	r2, r1, r2                                  <== NOT EXECUTED
a000b824:	01c320b0 	strheq	r2, [r3]                                   <== NOT EXECUTED
a000b828:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b830 <_Scheduler_priority_Free>: void _Scheduler_priority_Free ( Thread_Control *the_thread ) { _Workspace_Free( the_thread->scheduler_info );
a000b830:	e590008c 	ldr	r0, [r0, #140]	; 0x8c                         <== NOT EXECUTED
a000b834:	ea000641 	b	a000d140 <_Workspace_Free>                      <== NOT EXECUTED
                                                                      

a000b8b8 <_Scheduler_priority_Schedule>: RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void ) { Priority_bit_map_Control minor; Priority_bit_map_Control major; _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
a000b8b8:	e59f306c 	ldr	r3, [pc, #108]	; a000b92c <_Scheduler_priority_Schedule+0x74><== NOT EXECUTED
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
a000b8bc:	e59f206c 	ldr	r2, [pc, #108]	; a000b930 <_Scheduler_priority_Schedule+0x78><== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
a000b8c0:	e59fc06c 	ldr	ip, [pc, #108]	; a000b934 <_Scheduler_priority_Schedule+0x7c><== NOT EXECUTED
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{                                                                     
  Priority_bit_map_Control minor;                                     
  Priority_bit_map_Control major;                                     
                                                                      
  _Bitfield_Find_first_bit( _Priority_Major_bit_map, major );         
a000b8c4:	e1d330b0 	ldrh	r3, [r3]                                     <== NOT EXECUTED
a000b8c8:	e5921000 	ldr	r1, [r2]                                      <== NOT EXECUTED
a000b8cc:	e1a03803 	lsl	r3, r3, #16                                   <== NOT EXECUTED
a000b8d0:	e35308ff 	cmp	r3, #16711680	; 0xff0000                      <== NOT EXECUTED
a000b8d4:	959f005c 	ldrls	r0, [pc, #92]	; a000b938 <_Scheduler_priority_Schedule+0x80><== NOT EXECUTED
a000b8d8:	859f0058 	ldrhi	r0, [pc, #88]	; a000b938 <_Scheduler_priority_Schedule+0x80><== NOT EXECUTED
a000b8dc:	97d03823 	ldrbls	r3, [r0, r3, lsr #16]                      <== NOT EXECUTED
a000b8e0:	87d03c23 	ldrbhi	r3, [r0, r3, lsr #24]                      <== NOT EXECUTED
a000b8e4:	92833008 	addls	r3, r3, #8                                  <== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );        
a000b8e8:	e1a02083 	lsl	r2, r3, #1                                    <== NOT EXECUTED
a000b8ec:	e19c20b2 	ldrh	r2, [ip, r2]                                 <== NOT EXECUTED
a000b8f0:	e35200ff 	cmp	r2, #255	; 0xff                               <== NOT EXECUTED
a000b8f4:	97d02002 	ldrbls	r2, [r0, r2]                               <== NOT EXECUTED
a000b8f8:	87d02422 	ldrbhi	r2, [r0, r2, lsr #8]                       <== NOT EXECUTED
a000b8fc:	e59f0038 	ldr	r0, [pc, #56]	; a000b93c <_Scheduler_priority_Schedule+0x84><== NOT EXECUTED
a000b900:	92822008 	addls	r2, r2, #8                                  <== NOT EXECUTED
                                                                      
  return (_Priority_Bits_index( major ) << 4) +                       
a000b904:	e0823203 	add	r3, r2, r3, lsl #4                            <== NOT EXECUTED
  Chain_Control       *the_ready_queue                                
)                                                                     
{                                                                     
  Priority_Control index = _Priority_bit_map_Get_highest();           
                                                                      
  if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )                
a000b908:	e3a0200c 	mov	r2, #12                                       <== NOT EXECUTED
a000b90c:	e0020293 	mul	r2, r3, r2                                    <== NOT EXECUTED
#include <rtems/score/schedulerpriority.h>                            
                                                                      
void _Scheduler_priority_Schedule(void)                               
{                                                                     
  _Scheduler_priority_Schedule_body();                                
}                                                                     
a000b910:	e7913002 	ldr	r3, [r1, r2]                                  <== NOT EXECUTED
a000b914:	e0812002 	add	r2, r1, r2                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a000b918:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
    return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
a000b91c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000b920:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
 *                                                                    
 *  @param[in] the_thread  - pointer to thread                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)     
{                                                                     
  _Thread_Heir = _Scheduler_priority_Ready_queue_first(               
a000b924:	e5803008 	str	r3, [r0, #8]                                  <== NOT EXECUTED
a000b928:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b940 <_Scheduler_priority_Unblock>: ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
a000b940:	e590308c 	ldr	r3, [r0, #140]	; 0x8c                         
#include <rtems/score/schedulerpriority.h>                            
                                                                      
void _Scheduler_priority_Unblock (                                    
  Thread_Control          *the_thread                                 
)                                                                     
{                                                                     
a000b944:	e92d00f0 	push	{r4, r5, r6, r7}                             
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b948:	e5934004 	ldr	r4, [r3, #4]                                  
a000b94c:	e1d360ba 	ldrh	r6, [r3, #10]                                
  ready      = sched_info->ready_chain;                               
a000b950:	e5932000 	ldr	r2, [r3]                                      
a000b954:	e1d470b0 	ldrh	r7, [r4]                                     
   *    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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
a000b958:	e59f1078 	ldr	r1, [pc, #120]	; a000b9d8 <_Scheduler_priority_Unblock+0x98>
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b95c:	e59fc078 	ldr	ip, [pc, #120]	; a000b9dc <_Scheduler_priority_Unblock+0x9c>
                                                                      
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (                     
  Priority_bit_map_Information *the_priority_map                      
)                                                                     
{                                                                     
  *the_priority_map->minor |= the_priority_map->ready_minor;          
a000b960:	e1876006 	orr	r6, r7, r6                                    
a000b964:	e1c460b0 	strh	r6, [r4]                                     
  _Priority_Major_bit_map  |= the_priority_map->ready_major;          
a000b968:	e1d360b8 	ldrh	r6, [r3, #8]                                 
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a000b96c:	e5923008 	ldr	r3, [r2, #8]                                  
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a000b970:	e5820008 	str	r0, [r2, #8]                                  
a000b974:	e5914008 	ldr	r4, [r1, #8]                                  
a000b978:	e1dc70b0 	ldrh	r7, [ip]                                     
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000b97c:	e2825004 	add	r5, r2, #4                                    
a000b980:	e5944014 	ldr	r4, [r4, #20]                                 
a000b984:	e5902014 	ldr	r2, [r0, #20]                                 
a000b988:	e1876006 	orr	r6, r7, r6                                    
a000b98c:	e1cc60b0 	strh	r6, [ip]                                     
a000b990:	e1520004 	cmp	r2, r4                                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a000b994:	e5805000 	str	r5, [r0]                                      
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
a000b998:	e5803004 	str	r3, [r0, #4]                                  
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a000b99c:	e5830000 	str	r0, [r3]                                      
a000b9a0:	2a000006 	bcs	a000b9c0 <_Scheduler_priority_Unblock+0x80>   
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
a000b9a4:	e5913004 	ldr	r3, [r1, #4]                                  
   *  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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
    _Thread_Heir = the_thread;                                        
a000b9a8:	e5810008 	str	r0, [r1, #8]                                  
    if ( _Thread_Executing->is_preemptible ||                         
a000b9ac:	e5d33074 	ldrb	r3, [r3, #116]	; 0x74                        
a000b9b0:	e3530000 	cmp	r3, #0                                        
a000b9b4:	0a000003 	beq	a000b9c8 <_Scheduler_priority_Unblock+0x88>   
        the_thread->current_priority == 0 )                           
      _Thread_Dispatch_necessary = true;                              
a000b9b8:	e3a03001 	mov	r3, #1                                        
a000b9bc:	e5c13010 	strb	r3, [r1, #16]                                
  }                                                                   
}                                                                     
a000b9c0:	e8bd00f0 	pop	{r4, r5, r6, r7}                              
a000b9c4:	e12fff1e 	bx	lr                                             
   *    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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
a000b9c8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        the_thread->current_priority == 0 )                           
      _Thread_Dispatch_necessary = true;                              
a000b9cc:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
a000b9d0:	05c13010 	strbeq	r3, [r1, #16]                              <== NOT EXECUTED
a000b9d4:	eafffff9 	b	a000b9c0 <_Scheduler_priority_Unblock+0x80>     <== NOT EXECUTED
                                                                      

a000ba58 <_Scheduler_priority_Yield>: Scheduler_priority_Per_thread *sched_info; ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing;
a000ba58:	e59f1094 	ldr	r1, [pc, #148]	; a000baf4 <_Scheduler_priority_Yield+0x9c><== NOT EXECUTED
 *    ready chain                                                     
 *    select heir                                                     
 */                                                                   
                                                                      
void _Scheduler_priority_Yield(void)                                  
{                                                                     
a000ba5c:	e92d0070 	push	{r4, r5, r6}                                 <== NOT EXECUTED
  Scheduler_priority_Per_thread *sched_info;                          
  ISR_Level                      level;                               
  Thread_Control                *executing;                           
  Chain_Control                 *ready;                               
                                                                      
  executing  = _Thread_Executing;                                     
a000ba60:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
  sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
  ready      = sched_info->ready_chain;                               
a000ba64:	e593208c 	ldr	r2, [r3, #140]	; 0x8c                         <== NOT EXECUTED
a000ba68:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000ba6c:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a000ba70:	e380c080 	orr	ip, r0, #128	; 0x80                           <== NOT EXECUTED
a000ba74:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
  _ISR_Disable( level );                                              
    if ( !_Chain_Has_only_one_node( ready ) ) {                       
a000ba78:	e5924000 	ldr	r4, [r2]                                      <== NOT EXECUTED
a000ba7c:	e592c008 	ldr	ip, [r2, #8]                                  <== NOT EXECUTED
a000ba80:	e154000c 	cmp	r4, ip                                        <== NOT EXECUTED
a000ba84:	0a000016 	beq	a000bae4 <_Scheduler_priority_Yield+0x8c>     <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a000ba88:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
  previous       = the_node->previous;                                
a000ba8c:	e5934004 	ldr	r4, [r3, #4]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000ba90:	e2826004 	add	r6, r2, #4                                    <== NOT EXECUTED
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000ba94:	e5854004 	str	r4, [r5, #4]                                  <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a000ba98:	e592c008 	ldr	ip, [r2, #8]                                  <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a000ba9c:	e5823008 	str	r3, [r2, #8]                                  <== NOT EXECUTED
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
  previous->next = next;                                              
a000baa0:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
a000baa4:	e8831040 	stm	r3, {r6, ip}                                  <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a000baa8:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000baac:	e10fc000 	mrs	ip, CPSR                                      <== NOT EXECUTED
a000bab0:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a000bab4:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
      _Chain_Extract_unprotected( &executing->Object.Node );          
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
a000bab8:	e591c008 	ldr	ip, [r1, #8]                                  <== NOT EXECUTED
a000babc:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a000bac0:	0a000004 	beq	a000bad8 <_Scheduler_priority_Yield+0x80>     <== NOT EXECUTED
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
      _Thread_Dispatch_necessary = true;                              
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
      _Thread_Dispatch_necessary = true;                              
a000bac4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000bac8:	e5c13010 	strb	r3, [r1, #16]                                <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bacc:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
}                                                                     
a000bad0:	e8bd0070 	pop	{r4, r5, r6}                                  <== NOT EXECUTED
a000bad4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
      _Chain_Append_unprotected( ready, &executing->Object.Node );    
                                                                      
      _ISR_Flash( level );                                            
                                                                      
      if ( _Thread_Is_heir( executing ) )                             
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );      
a000bad8:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
a000badc:	e5813008 	str	r3, [r1, #8]                                  <== NOT EXECUTED
a000bae0:	eafffff7 	b	a000bac4 <_Scheduler_priority_Yield+0x6c>       <== NOT EXECUTED
      _Thread_Dispatch_necessary = true;                              
    }                                                                 
    else if ( !_Thread_Is_heir( executing ) )                         
a000bae4:	e5912008 	ldr	r2, [r1, #8]                                  <== NOT EXECUTED
a000bae8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000baec:	1afffff4 	bne	a000bac4 <_Scheduler_priority_Yield+0x6c>     <== NOT EXECUTED
a000baf0:	eafffff5 	b	a000bacc <_Scheduler_priority_Yield+0x74>       <== NOT EXECUTED
                                                                      

a000bb88 <_Scheduler_simple_Block>: #include <rtems/score/schedulersimple.h> void _Scheduler_simple_Block( Thread_Control *the_thread ) {
a000bb88:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (                           
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Heir );                              
a000bb8c:	e59f5030 	ldr	r5, [pc, #48]	; a000bbc4 <_Scheduler_simple_Block+0x3c><== NOT EXECUTED
a000bb90:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  _Scheduler_simple_Extract(the_thread);                              
a000bb94:	eb00000d 	bl	a000bbd0 <_Scheduler_simple_Extract>           <== NOT EXECUTED
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
a000bb98:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
a000bb9c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000bba0:	0a000005 	beq	a000bbbc <_Scheduler_simple_Block+0x34>       <== NOT EXECUTED
    _Scheduler_simple_Schedule();                                     
                                                                      
  if ( _Thread_Is_executing( the_thread ) )                           
a000bba4:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
a000bba8:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    _Thread_Dispatch_necessary = true;                                
a000bbac:	059f3010 	ldreq	r3, [pc, #16]	; a000bbc4 <_Scheduler_simple_Block+0x3c><== NOT EXECUTED
a000bbb0:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
a000bbb4:	05c32010 	strbeq	r2, [r3, #16]                              <== NOT EXECUTED
a000bbb8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  _Scheduler_simple_Extract(the_thread);                              
                                                                      
  if ( _Thread_Is_heir( the_thread ) )                                
    _Scheduler_simple_Schedule();                                     
a000bbbc:	eb000048 	bl	a000bce4 <_Scheduler_simple_Schedule>          <== NOT EXECUTED
a000bbc0:	eafffff7 	b	a000bba4 <_Scheduler_simple_Block+0x1c>         <== NOT EXECUTED
                                                                      

a000bbcc <_Scheduler_simple_Enqueue>: void _Scheduler_simple_Enqueue( Thread_Control *the_thread ) { _Scheduler_simple_Ready_queue_Enqueue( the_thread );
a000bbcc:	ea000026 	b	a000bc6c <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
                                                                      

a000bbc8 <_Scheduler_simple_Enqueue_first>: void _Scheduler_simple_Enqueue_first( Thread_Control *the_thread ) { _Scheduler_simple_Ready_queue_Enqueue_first( the_thread );
a000bbc8:	ea000014 	b	a000bc20 <_Scheduler_simple_Ready_queue_Enqueue_first><== NOT EXECUTED
                                                                      

a000bbd0 <_Scheduler_simple_Extract>: ) { Chain_Node *next; Chain_Node *previous; next = the_node->next;
a000bbd0:	e890000c 	ldm	r0, {r2, r3}                                  <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000bbd4:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000bbd8:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
void _Scheduler_simple_Extract(                                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
}                                                                     
a000bbdc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000bbec <_Scheduler_simple_Free>: */ void _Scheduler_simple_Free( Thread_Control *the_thread ) { }
a000bbec:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000bc6c <_Scheduler_simple_Ready_queue_Enqueue>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information;
a000bc6c:	e59f306c 	ldr	r3, [pc, #108]	; a000bce0 <_Scheduler_simple_Ready_queue_Enqueue+0x74>
#include <rtems/score/schedulersimple.h>                              
                                                                      
void _Scheduler_simple_Ready_queue_Enqueue(                           
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
a000bc70:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 
  Chain_Control    *ready;                                            
  Chain_Node       *the_node;                                         
  Thread_Control   *current;                                          
                                                                      
  ready    = (Chain_Control *)_Scheduler.information;                 
a000bc74:	e5931000 	ldr	r1, [r3]                                      
    }                                                                 
  }                                                                   
                                                                      
  /* enqueue */                                                       
  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}                                                                     
a000bc78:	e1a0c001 	mov	ip, r1                                        
a000bc7c:	e49c3004 	ldr	r3, [ip], #4                                  
                                                                      
  ready    = (Chain_Control *)_Scheduler.information;                 
  the_node = _Chain_First( ready );                                   
  current  = (Thread_Control *)ready;                                 
                                                                      
  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
a000bc80:	e153000c 	cmp	r3, ip                                        
a000bc84:	0a00000c 	beq	a000bcbc <_Scheduler_simple_Ready_queue_Enqueue+0x50>
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT END OR PAST our priority */                      
    if ( the_thread->current_priority < current->current_priority ) { 
a000bc88:	e5904014 	ldr	r4, [r0, #20]                                 <== NOT EXECUTED
a000bc8c:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
  ready    = (Chain_Control *)_Scheduler.information;                 
  the_node = _Chain_First( ready );                                   
  current  = (Thread_Control *)ready;                                 
                                                                      
  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
a000bc90:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
                                                                      
    /* break when AT END OR PAST our priority */                      
    if ( the_thread->current_priority < current->current_priority ) { 
a000bc94:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
a000bc98:	2a000004 	bcs	a000bcb0 <_Scheduler_simple_Ready_queue_Enqueue+0x44><== NOT EXECUTED
a000bc9c:	ea00000d 	b	a000bcd8 <_Scheduler_simple_Ready_queue_Enqueue+0x6c><== NOT EXECUTED
a000bca0:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
  ready    = (Chain_Control *)_Scheduler.information;                 
  the_node = _Chain_First( ready );                                   
  current  = (Thread_Control *)ready;                                 
                                                                      
  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
a000bca4:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
                                                                      
    /* break when AT END OR PAST our priority */                      
    if ( the_thread->current_priority < current->current_priority ) { 
a000bca8:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000bcac:	8a000009 	bhi	a000bcd8 <_Scheduler_simple_Ready_queue_Enqueue+0x6c><== NOT EXECUTED
                                                                      
  ready    = (Chain_Control *)_Scheduler.information;                 
  the_node = _Chain_First( ready );                                   
  current  = (Thread_Control *)ready;                                 
                                                                      
  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
a000bcb0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000bcb4:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a000bcb8:	1afffff8 	bne	a000bca0 <_Scheduler_simple_Ready_queue_Enqueue+0x34><== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a000bcbc:	e5913000 	ldr	r3, [r1]                                      
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a000bcc0:	e5801004 	str	r1, [r0, #4]                                  
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000bcc4:	e5810000 	str	r0, [r1]                                      
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a000bcc8:	e5830004 	str	r0, [r3, #4]                                  
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a000bccc:	e5803000 	str	r3, [r0]                                      
    }                                                                 
  }                                                                   
                                                                      
  /* enqueue */                                                       
  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}                                                                     
a000bcd0:	e8bd0010 	pop	{r4}                                          
a000bcd4:	e12fff1e 	bx	lr                                             
  for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT END OR PAST our priority */                      
    if ( the_thread->current_priority < current->current_priority ) { 
      current = (Thread_Control *)current->Object.Node.previous;      
a000bcd8:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
      break;                                                          
a000bcdc:	eafffff6 	b	a000bcbc <_Scheduler_simple_Ready_queue_Enqueue+0x50><== NOT EXECUTED
                                                                      

a000bc20 <_Scheduler_simple_Ready_queue_Enqueue_first>: } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); }
a000bc20:	e59f3040 	ldr	r3, [pc, #64]	; a000bc68 <_Scheduler_simple_Ready_queue_Enqueue_first+0x48><== NOT EXECUTED
   */                                                                 
  for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT HEAD OF (or PAST) our priority */                
    if ( the_thread->current_priority <= current->current_priority ) {
a000bc24:	e5901014 	ldr	r1, [r0, #20]                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* enqueue */                                                       
  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}                                                                     
a000bc28:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000bc2c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
   */                                                                 
  for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT HEAD OF (or PAST) our priority */                
    if ( the_thread->current_priority <= current->current_priority ) {
a000bc30:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
a000bc34:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000bc38:	9a000003 	bls	a000bc4c <_Scheduler_simple_Ready_queue_Enqueue_first+0x2c><== NOT EXECUTED
   * Do NOT need to check for end of chain because there is always    
   * at least one task on the ready chain -- the IDLE task.  It can   
   * never block, should never attempt to obtain a semaphore or mutex,
   * and thus will always be there.                                   
   */                                                                 
  for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
a000bc3c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    current = (Thread_Control *) the_node;                            
                                                                      
    /* break when AT HEAD OF (or PAST) our priority */                
    if ( the_thread->current_priority <= current->current_priority ) {
a000bc40:	e5932014 	ldr	r2, [r3, #20]                                 <== NOT EXECUTED
a000bc44:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
a000bc48:	3afffffb 	bcc	a000bc3c <_Scheduler_simple_Ready_queue_Enqueue_first+0x1c><== NOT EXECUTED
      current = (Thread_Control *)current->Object.Node.previous;      
a000bc4c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a000bc50:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a000bc54:	e5803004 	str	r3, [r0, #4]                                  <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000bc58:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a000bc5c:	e5820004 	str	r0, [r2, #4]                                  <== NOT EXECUTED
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a000bc60:	e5802000 	str	r2, [r0]                                      <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  /* enqueue */                                                       
  _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}                                                                     
a000bc64:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000bce4 <_Scheduler_simple_Schedule>: #include <rtems/score/schedulersimple.h> void _Scheduler_simple_Schedule(void) { _Thread_Heir = (Thread_Control *) _Chain_First( (Chain_Control *) _Scheduler.information
a000bce4:	e59f3010 	ldr	r3, [pc, #16]	; a000bcfc <_Scheduler_simple_Schedule+0x18><== NOT EXECUTED
  );                                                                  
}                                                                     
a000bce8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
#include <rtems/score/thread.h>                                       
#include <rtems/score/schedulersimple.h>                              
                                                                      
void _Scheduler_simple_Schedule(void)                                 
{                                                                     
  _Thread_Heir = (Thread_Control *) _Chain_First(                     
a000bcec:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000bcf0:	e59f3008 	ldr	r3, [pc, #8]	; a000bd00 <_Scheduler_simple_Schedule+0x1c><== NOT EXECUTED
a000bcf4:	e5832008 	str	r2, [r3, #8]                                  <== NOT EXECUTED
    (Chain_Control *) _Scheduler.information                          
  );                                                                  
}                                                                     
a000bcf8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000bd04 <_Scheduler_simple_Unblock>: #include <rtems/score/thread.h> void _Scheduler_simple_Unblock( Thread_Control *the_thread ) {
a000bd04:	e92d4010 	push	{r4, lr}                                     
a000bd08:	e1a04000 	mov	r4, r0                                        
  _Scheduler_simple_Ready_queue_Enqueue(the_thread);                  
a000bd0c:	ebffffd6 	bl	a000bc6c <_Scheduler_simple_Ready_queue_Enqueue>
   *    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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
a000bd10:	e59f3040 	ldr	r3, [pc, #64]	; a000bd58 <_Scheduler_simple_Unblock+0x54>
a000bd14:	e5942014 	ldr	r2, [r4, #20]                                 
a000bd18:	e5931008 	ldr	r1, [r3, #8]                                  
a000bd1c:	e5911014 	ldr	r1, [r1, #20]                                 
a000bd20:	e1520001 	cmp	r2, r1                                        
a000bd24:	2a000006 	bcs	a000bd44 <_Scheduler_simple_Unblock+0x40>     
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
a000bd28:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
   *  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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
    _Thread_Heir = the_thread;                                        
a000bd2c:	e5834008 	str	r4, [r3, #8]                                  <== NOT EXECUTED
    if ( _Thread_Executing->is_preemptible ||                         
a000bd30:	e5d11074 	ldrb	r1, [r1, #116]	; 0x74                        <== NOT EXECUTED
a000bd34:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000bd38:	0a000002 	beq	a000bd48 <_Scheduler_simple_Unblock+0x44>     <== NOT EXECUTED
        the_thread->current_priority == 0 )                           
      _Thread_Dispatch_necessary = true;                              
a000bd3c:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000bd40:	e5c32010 	strb	r2, [r3, #16]                                <== NOT EXECUTED
a000bd44:	e8bd8010 	pop	{r4, pc}                                      
   *    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 ( the_thread->current_priority < _Thread_Heir->current_priority ) {
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
a000bd48:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        the_thread->current_priority == 0 )                           
      _Thread_Dispatch_necessary = true;                              
a000bd4c:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
a000bd50:	05c32010 	strbeq	r2, [r3, #16]                              <== NOT EXECUTED
a000bd54:	eafffffa 	b	a000bd44 <_Scheduler_simple_Unblock+0x40>       <== NOT EXECUTED
                                                                      

a000bd5c <_Scheduler_simple_Yield>: #include <rtems/score/scheduler.h> #include <rtems/score/thread.h> #include <rtems/score/schedulersimple.h> void _Scheduler_simple_Yield( void ) {
a000bd5c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  ISR_Level       level;                                              
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
a000bd60:	e59f5048 	ldr	r5, [pc, #72]	; a000bdb0 <_Scheduler_simple_Yield+0x54><== NOT EXECUTED
a000bd64:	e5954004 	ldr	r4, [r5, #4]                                  <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000bd68:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a000bd6c:	e3863080 	orr	r3, r6, #128	; 0x80                           <== NOT EXECUTED
a000bd70:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a000bd74:	e894000c 	ldm	r4, {r2, r3}                                  <== NOT EXECUTED
{                                                                     
  /* extract */                                                       
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
                                                                      
  /* enqueue */                                                       
  _Scheduler_simple_Ready_queue_Enqueue( the_thread );                
a000bd78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
a000bd7c:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000bd80:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
a000bd84:	ebffffb8 	bl	a000bc6c <_Scheduler_simple_Ready_queue_Enqueue><== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000bd88:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a000bd8c:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
a000bd90:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
    _Scheduler_simple_Ready_queue_Requeue(&_Scheduler, executing);    
                                                                      
    _ISR_Flash( level );                                              
                                                                      
    _Scheduler_simple_Schedule();                                     
a000bd94:	ebffffd2 	bl	a000bce4 <_Scheduler_simple_Schedule>          <== NOT EXECUTED
                                                                      
    if ( !_Thread_Is_heir( executing ) )                              
a000bd98:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
a000bd9c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
      _Thread_Dispatch_necessary = true;                              
a000bda0:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
a000bda4:	15c53010 	strbne	r3, [r5, #16]                              <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bda8:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
}                                                                     
a000bdac:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0009c24 <_Semaphore_Translate_core_semaphore_return_code>: */ #if defined(RTEMS_DEBUG) if ( status > CORE_SEMAPHORE_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_semaphore_return_code_[status];
a0009c24:	e59f3008 	ldr	r3, [pc, #8]	; a0009c34 <_Semaphore_Translate_core_semaphore_return_code+0x10><== NOT EXECUTED
a0009c28:	e0833100 	add	r3, r3, r0, lsl #2                            <== NOT EXECUTED
}                                                                     
a0009c2c:	e5930018 	ldr	r0, [r3, #24]                                 <== NOT EXECUTED
a0009c30:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000f264 <_TOD_Get_uptime>: */ void _TOD_Get_uptime( Timestamp_Control *uptime ) {
a000f264:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000f268:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000f26c:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000f270:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a000f274:	e3853080 	orr	r3, r5, #128	; 0x80                           <== NOT EXECUTED
a000f278:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
  /* assume time checked for NULL by caller */                        
                                                                      
  /* _TOD_Uptime is in native timestamp format */                     
  _ISR_Disable( level );                                              
    up = _TOD_Uptime;                                                 
a000f27c:	e59f3040 	ldr	r3, [pc, #64]	; a000f2c4 <_TOD_Get_uptime+0x60><== NOT EXECUTED
a000f280:	e8930006 	ldm	r3, {r1, r2}                                  <== NOT EXECUTED
    nanoseconds = (*_Watchdog_Nanoseconds_since_tick_handler)();      
a000f284:	e59f303c 	ldr	r3, [pc, #60]	; a000f2c8 <_TOD_Get_uptime+0x64><== NOT EXECUTED
                                                                      
  /* assume time checked for NULL by caller */                        
                                                                      
  /* _TOD_Uptime is in native timestamp format */                     
  _ISR_Disable( level );                                              
    up = _TOD_Uptime;                                                 
a000f288:	e88d0006 	stm	sp, {r1, r2}                                  <== NOT EXECUTED
    nanoseconds = (*_Watchdog_Nanoseconds_since_tick_handler)();      
a000f28c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000f290:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000f294:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000f298:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
                                                                      
  _Timestamp_Set( &offset, 0, nanoseconds );                          
a000f29c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  _Timestamp_Add_to( &up, &offset );                                  
a000f2a0:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000f2a4:	e28d1008 	add	r1, sp, #8                                    <== NOT EXECUTED
  _ISR_Disable( level );                                              
    up = _TOD_Uptime;                                                 
    nanoseconds = (*_Watchdog_Nanoseconds_since_tick_handler)();      
  _ISR_Enable( level );                                               
                                                                      
  _Timestamp_Set( &offset, 0, nanoseconds );                          
a000f2a8:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a000f2ac:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
  _Timestamp_Add_to( &up, &offset );                                  
a000f2b0:	ebfff5e6 	bl	a000ca50 <_Timespec_Add_to>                    <== NOT EXECUTED
  *uptime = up;                                                       
a000f2b4:	e89d000c 	ldm	sp, {r2, r3}                                  <== NOT EXECUTED
a000f2b8:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
}                                                                     
a000f2bc:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a000f2c0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000ac60 <_TOD_Get_uptime_as_timespec>: */ void _TOD_Get_uptime_as_timespec( struct timespec *uptime ) {
a000ac60:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000ac64:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a000ac68:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  Timestamp_Control uptime_ts;                                        
                                                                      
  /* assume time checked for NULL by caller */                        
  _TOD_Get_uptime( &uptime_ts );                                      
a000ac6c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000ac70:	eb0012a7 	bl	a000f714 <_TOD_Get_uptime>                     <== NOT EXECUTED
  _Timestamp_To_timespec( &uptime_ts, uptime );                       
a000ac74:	e89d000c 	ldm	sp, {r2, r3}                                  <== NOT EXECUTED
a000ac78:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
}                                                                     
a000ac7c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000ac80:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000c33c <_TOD_Set>: rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1;
a000c33c:	e59f3068 	ldr	r3, [pc, #104]	; a000c3ac <_TOD_Set+0x70>     <== NOT EXECUTED
 */                                                                   
                                                                      
void _TOD_Set(                                                        
  const struct timespec *time                                         
)                                                                     
{                                                                     
a000c340:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000c344:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000c348:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000c34c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000c350:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
  long seconds;                                                       
                                                                      
  _Thread_Disable_dispatch();                                         
  _TOD_Deactivate();                                                  
                                                                      
  seconds = _TOD_Seconds_since_epoch();                               
a000c354:	e59f4054 	ldr	r4, [pc, #84]	; a000c3b0 <_TOD_Set+0x74>      <== NOT EXECUTED
                                                                      
  if ( time->tv_sec < seconds )                                       
a000c358:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
  long seconds;                                                       
                                                                      
  _Thread_Disable_dispatch();                                         
  _TOD_Deactivate();                                                  
                                                                      
  seconds = _TOD_Seconds_since_epoch();                               
a000c35c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  if ( time->tv_sec < seconds )                                       
a000c360:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a000c364:	ca00000b 	bgt	a000c398 <_TOD_Set+0x5c>                      <== NOT EXECUTED
  Watchdog_Adjust_directions direction,                               
  Watchdog_Interval          units                                    
)                                                                     
{                                                                     
                                                                      
  _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );     
a000c368:	e59f0044 	ldr	r0, [pc, #68]	; a000c3b4 <_TOD_Set+0x78>      <== NOT EXECUTED
a000c36c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000c370:	e0632002 	rsb	r2, r3, r2                                    <== NOT EXECUTED
a000c374:	eb0009be 	bl	a000ea74 <_Watchdog_Adjust>                    <== NOT EXECUTED
    _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
  else                                                                
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
                                                                      
  /* POSIX format TOD (timespec) */                                   
  _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );           
a000c378:	e895000c 	ldm	r5, {r2, r3}                                  <== NOT EXECUTED
a000c37c:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
  _TOD_Is_set = true;                                                 
a000c380:	e59f3030 	ldr	r3, [pc, #48]	; a000c3b8 <_TOD_Set+0x7c>      <== NOT EXECUTED
    _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
  else                                                                
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
                                                                      
  /* POSIX format TOD (timespec) */                                   
  _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );           
a000c384:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
  _TOD_Is_set = true;                                                 
a000c388:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000c38c:	e5c32000 	strb	r2, [r3]                                     <== NOT EXECUTED
                                                                      
  _TOD_Activate();                                                    
                                                                      
  _Thread_Enable_dispatch();                                          
}                                                                     
a000c390:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
  _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );           
  _TOD_Is_set = true;                                                 
                                                                      
  _TOD_Activate();                                                    
                                                                      
  _Thread_Enable_dispatch();                                          
a000c394:	ea000605 	b	a000dbb0 <_Thread_Enable_dispatch>              <== NOT EXECUTED
a000c398:	e59f0014 	ldr	r0, [pc, #20]	; a000c3b4 <_TOD_Set+0x78>      <== NOT EXECUTED
a000c39c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000c3a0:	e0622003 	rsb	r2, r2, r3                                    <== NOT EXECUTED
a000c3a4:	eb0009b2 	bl	a000ea74 <_Watchdog_Adjust>                    <== NOT EXECUTED
a000c3a8:	eafffff2 	b	a000c378 <_TOD_Set+0x3c>                        <== NOT EXECUTED
                                                                      

a000a8c8 <_TOD_Tickle_ticks>: { Timestamp_Control tick; uint32_t seconds; /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
a000a8c8:	e59f2064 	ldr	r2, [pc, #100]	; a000a934 <_TOD_Tickle_ticks+0x6c><== NOT EXECUTED
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
a000a8cc:	e59f3064 	ldr	r3, [pc, #100]	; a000a938 <_TOD_Tickle_ticks+0x70><== NOT EXECUTED
 *                                                                    
 *  Output parameters: NONE                                           
 */                                                                   
                                                                      
void _TOD_Tickle_ticks( void )                                        
{                                                                     
a000a8d0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
a000a8d4:	e592100c 	ldr	r1, [r2, #12]                                 <== NOT EXECUTED
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
a000a8d8:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
a000a8dc:	e3a0cffa 	mov	ip, #1000	; 0x3e8                             <== NOT EXECUTED
a000a8e0:	e00c0c91 	mul	ip, r1, ip                                    <== NOT EXECUTED
 *                                                                    
 *  Output parameters: NONE                                           
 */                                                                   
                                                                      
void _TOD_Tickle_ticks( void )                                        
{                                                                     
a000a8e4:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
a000a8e8:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
a000a8ec:	e3a0e000 	mov	lr, #0                                        <== NOT EXECUTED
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
a000a8f0:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
a000a8f4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
a000a8f8:	e59f003c 	ldr	r0, [pc, #60]	; a000a93c <_TOD_Tickle_ticks+0x74><== NOT EXECUTED
{                                                                     
  Timestamp_Control tick;                                             
  uint32_t          seconds;                                          
                                                                      
  /* Convert the tick quantum to a timestamp */                       
  _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
a000a8fc:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
a000a900:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  /* Update the counter of ticks since boot */                        
  _Watchdog_Ticks_since_boot += 1;                                    
                                                                      
  /* Update the timespec format uptime */                             
  _Timestamp_Add_to( &_TOD_Uptime, &tick );                           
a000a904:	eb000851 	bl	a000ca50 <_Timespec_Add_to>                    <== NOT EXECUTED
  /* we do not care how much the uptime changed */                    
                                                                      
  /* Update the timespec format TOD */                                
  seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );            
a000a908:	e59f0030 	ldr	r0, [pc, #48]	; a000a940 <_TOD_Tickle_ticks+0x78><== NOT EXECUTED
a000a90c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000a910:	eb00084e 	bl	a000ca50 <_Timespec_Add_to>                    <== NOT EXECUTED
  while ( seconds ) {                                                 
a000a914:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a000a918:	0a000003 	beq	a000a92c <_TOD_Tickle_ticks+0x64>             <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )            
{                                                                     
                                                                      
  _Watchdog_Tickle( &_Watchdog_Seconds_chain );                       
a000a91c:	e59f0020 	ldr	r0, [pc, #32]	; a000a944 <_TOD_Tickle_ticks+0x7c><== NOT EXECUTED
a000a920:	eb0009be 	bl	a000d020 <_Watchdog_Tickle>                    <== NOT EXECUTED
a000a924:	e2544001 	subs	r4, r4, #1                                   <== NOT EXECUTED
a000a928:	1afffffb 	bne	a000a91c <_TOD_Tickle_ticks+0x54>             <== NOT EXECUTED
    _Watchdog_Tickle_seconds();                                       
    seconds--;                                                        
  }                                                                   
}                                                                     
a000a92c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000a930:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000aa5c <_TOD_To_seconds>: { uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; year_mod_4 = the_tod->year & 3;
a000aa5c:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
 */                                                                   
                                                                      
uint32_t   _TOD_To_seconds(                                           
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
a000aa60:	e92d01f0 	push	{r4, r5, r6, r7, r8}                         <== NOT EXECUTED
  uint32_t   year_mod_4;                                              
                                                                      
  time = the_tod->day - 1;                                            
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
a000aa64:	e2121003 	ands	r1, r2, #3                                   <== NOT EXECUTED
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
a000aa68:	05903004 	ldreq	r3, [r0, #4]                                <== NOT EXECUTED
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
a000aa6c:	15903004 	ldrne	r3, [r0, #4]                                <== NOT EXECUTED
                                                                      
  time = the_tod->day - 1;                                            
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
a000aa70:	059fc07c 	ldreq	ip, [pc, #124]	; a000aaf4 <_TOD_To_seconds+0x98><== NOT EXECUTED
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
a000aa74:	159fc078 	ldrne	ip, [pc, #120]	; a000aaf4 <_TOD_To_seconds+0x98><== NOT EXECUTED
a000aa78:	11a03083 	lslne	r3, r3, #1                                  <== NOT EXECUTED
                                                                      
  time = the_tod->day - 1;                                            
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
a000aa7c:	008c3083 	addeq	r3, ip, r3, lsl #1                          <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   time;                                                    
  uint32_t   year_mod_4;                                              
                                                                      
  time = the_tod->day - 1;                                            
a000aa80:	e5904008 	ldr	r4, [r0, #8]                                  <== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
a000aa84:	119c30b3 	ldrhne	r3, [ip, r3]                               <== NOT EXECUTED
                                                                      
  time = the_tod->day - 1;                                            
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
a000aa88:	01d331ba 	ldrheq	r3, [r3, #26]                              <== NOT EXECUTED
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
                                                                      
  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)  
a000aa8c:	e5908014 	ldr	r8, [r0, #20]                                 <== NOT EXECUTED
a000aa90:	e590700c 	ldr	r7, [r0, #12]                                 <== NOT EXECUTED
a000aa94:	e5906010 	ldr	r6, [r0, #16]                                 <== NOT EXECUTED
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
            ( (TOD_DAYS_PER_YEAR * 4) + 1);                           
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
a000aa98:	e08cc081 	add	ip, ip, r1, lsl #1                            <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   time;                                                    
  uint32_t   year_mod_4;                                              
                                                                      
  time = the_tod->day - 1;                                            
a000aa9c:	e2444001 	sub	r4, r4, #1                                    <== NOT EXECUTED
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
            ( (TOD_DAYS_PER_YEAR * 4) + 1);                           
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
a000aaa0:	e1dc53b4 	ldrh	r5, [ip, #52]	; 0x34                         <== NOT EXECUTED
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
                                                                      
  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)  
a000aaa4:	e3a0103c 	mov	r1, #60	; 0x3c                                <== NOT EXECUTED
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
a000aaa8:	e2420d1f 	sub	r0, r2, #1984	; 0x7c0                         <== NOT EXECUTED
                                                                      
  time = the_tod->day - 1;                                            
  year_mod_4 = the_tod->year & 3;                                     
                                                                      
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
a000aaac:	00834004 	addeq	r4, r3, r4                                  <== NOT EXECUTED
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
a000aab0:	10834004 	addne	r4, r3, r4                                  <== NOT EXECUTED
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
                                                                      
  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)  
a000aab4:	e2882587 	add	r2, r8, #566231040	; 0x21c00000               <== NOT EXECUTED
a000aab8:	e02c6791 	mla	ip, r1, r7, r6                                <== NOT EXECUTED
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
a000aabc:	e2400004 	sub	r0, r0, #4                                    <== NOT EXECUTED
a000aac0:	e3a03e5b 	mov	r3, #1456	; 0x5b0                             <== NOT EXECUTED
a000aac4:	e2833005 	add	r3, r3, #5                                    <== NOT EXECUTED
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
                                                                      
  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)  
a000aac8:	e282296b 	add	r2, r2, #1753088	; 0x1ac000                   <== NOT EXECUTED
  if ( year_mod_4 == 0 )                                              
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];                 
  else                                                                
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
a000aacc:	e1a00120 	lsr	r0, r0, #2                                    <== NOT EXECUTED
a000aad0:	e0205093 	mla	r0, r3, r0, r5                                <== NOT EXECUTED
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
                                                                      
  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)  
a000aad4:	e2823c25 	add	r3, r2, #9472	; 0x2500                        <== NOT EXECUTED
             * TOD_SECONDS_PER_MINUTE;                                
                                                                      
  time += the_tod->second;                                            
a000aad8:	e021319c 	mla	r1, ip, r1, r3                                <== NOT EXECUTED
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
            ( (TOD_DAYS_PER_YEAR * 4) + 1);                           
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
a000aadc:	e3a03a15 	mov	r3, #86016	; 0x15000                          <== NOT EXECUTED
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];                 
                                                                      
  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *                   
            ( (TOD_DAYS_PER_YEAR * 4) + 1);                           
                                                                      
  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];               
a000aae0:	e0800004 	add	r0, r0, r4                                    <== NOT EXECUTED
                                                                      
  time *= TOD_SECONDS_PER_DAY;                                        
a000aae4:	e2833d06 	add	r3, r3, #384	; 0x180                          <== NOT EXECUTED
  time += the_tod->second;                                            
                                                                      
  time += TOD_SECONDS_1970_THROUGH_1988;                              
                                                                      
  return( time );                                                     
}                                                                     
a000aae8:	e0201093 	mla	r0, r3, r0, r1                                <== NOT EXECUTED
a000aaec:	e8bd01f0 	pop	{r4, r5, r6, r7, r8}                          <== NOT EXECUTED
a000aaf0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000aaf8 <_TOD_Validate>: { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick();
a000aaf8:	e59f30bc 	ldr	r3, [pc, #188]	; a000abbc <_TOD_Validate+0xc4><== NOT EXECUTED
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
  const rtems_time_of_day *the_tod                                    
)                                                                     
{                                                                     
a000aafc:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
a000ab00:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
	    rtems_configuration_get_microseconds_per_tick();                 
a000ab04:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
  if ((!the_tod)                                  ||                  
a000ab08:	0a000029 	beq	a000abb4 <_TOD_Validate+0xbc>                 <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
a000ab0c:	e3a0093d 	mov	r0, #999424	; 0xf4000                         <== NOT EXECUTED
a000ab10:	e2800d09 	add	r0, r0, #576	; 0x240                          <== NOT EXECUTED
a000ab14:	eb00467d 	bl	a001c510 <__aeabi_uidiv>                       <== NOT EXECUTED
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
a000ab18:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
a000ab1c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000ab20:	9a00001f 	bls	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->ticks  >= ticks_per_second)       ||                  
a000ab24:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a000ab28:	e353003b 	cmp	r3, #59	; 0x3b                                <== NOT EXECUTED
a000ab2c:	8a00001c 	bhi	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
a000ab30:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
a000ab34:	e353003b 	cmp	r3, #59	; 0x3b                                <== NOT EXECUTED
a000ab38:	8a000019 	bhi	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
a000ab3c:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a000ab40:	e3530017 	cmp	r3, #23                                       <== NOT EXECUTED
a000ab44:	8a000016 	bhi	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
a000ab48:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
a000ab4c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ab50:	0a000016 	beq	a000abb0 <_TOD_Validate+0xb8>                 <== NOT EXECUTED
      (the_tod->month  == 0)                      ||                  
a000ab54:	e350000c 	cmp	r0, #12                                       <== NOT EXECUTED
a000ab58:	8a000011 	bhi	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
a000ab5c:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
      (the_tod->ticks  >= ticks_per_second)       ||                  
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
a000ab60:	e3a03d1f 	mov	r3, #1984	; 0x7c0                             <== NOT EXECUTED
a000ab64:	e2833003 	add	r3, r3, #3                                    <== NOT EXECUTED
a000ab68:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000ab6c:	9a00000c 	bls	a000aba4 <_TOD_Validate+0xac>                 <== NOT EXECUTED
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
a000ab70:	e5944008 	ldr	r4, [r4, #8]                                  <== NOT EXECUTED
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
a000ab74:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000ab78:	0a00000b 	beq	a000abac <_TOD_Validate+0xb4>                 <== NOT EXECUTED
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
a000ab7c:	e3120003 	tst	r2, #3                                        <== NOT EXECUTED
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
a000ab80:	059f3038 	ldreq	r3, [pc, #56]	; a000abc0 <_TOD_Validate+0xc8><== NOT EXECUTED
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
a000ab84:	159f3034 	ldrne	r3, [pc, #52]	; a000abc0 <_TOD_Validate+0xc8><== NOT EXECUTED
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
a000ab88:	0280000d 	addeq	r0, r0, #13                                 <== NOT EXECUTED
a000ab8c:	07930100 	ldreq	r0, [r3, r0, lsl #2]                        <== NOT EXECUTED
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
a000ab90:	17930100 	ldrne	r0, [r3, r0, lsl #2]                        <== NOT EXECUTED
 *    false - if the the_tod is invalid                               
 *                                                                    
 *  NOTE: This routine only works for leap-years through 2099.        
 */                                                                   
                                                                      
bool _TOD_Validate(                                                   
a000ab94:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
a000ab98:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
a000ab9c:	23a00001 	movcs	r0, #1                                      <== NOT EXECUTED
a000aba0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
     return false;                                                    
a000aba4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000aba8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
a000abac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  if ( the_tod->day > days_in_month )                                 
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
a000abb0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
     return false;                                                    
a000abb4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000abb8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000bb50 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
a000bb50:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a000bb54:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000bb58:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
a000bb5c:	e20260ff 	and	r6, r2, #255	; 0xff                           <== NOT EXECUTED
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
a000bb60:	e5905010 	ldr	r5, [r0, #16]                                 <== NOT EXECUTED
  /*                                                                  
   * Set a transient state for the thread so it is pulled off the Ready chains.
   * This will prevent it from being scheduled no matter what happens in an
   * ISR.                                                             
   */                                                                 
  _Thread_Set_transient( the_thread );                                
a000bb64:	eb000344 	bl	a000c87c <_Thread_Set_transient>               <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not bother recomputing all the priority related information if
   *  we are not REALLY changing priority.                            
   */                                                                 
 if ( the_thread->current_priority != new_priority )                  
a000bb68:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a000bb6c:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
a000bb70:	0a000002 	beq	a000bb80 <_Thread_Change_priority+0x30>       <== NOT EXECUTED
    _Thread_Set_priority( the_thread, new_priority );                 
a000bb74:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bb78:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000bb7c:	eb000325 	bl	a000c818 <_Thread_Set_priority>                <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000bb80:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
a000bb84:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
a000bb88:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the thread has more than STATES_TRANSIENT set, then it is blocked,
   *  If it is blocked on a thread queue, then we need to requeue it. 
   */                                                                 
  state = the_thread->current_state;                                  
a000bb8c:	e5942010 	ldr	r2, [r4, #16]                                 <== NOT EXECUTED
  if ( state != STATES_TRANSIENT ) {                                  
a000bb90:	e3520004 	cmp	r2, #4                                        <== NOT EXECUTED
a000bb94:	0a000009 	beq	a000bbc0 <_Thread_Change_priority+0x70>       <== NOT EXECUTED
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
a000bb98:	e3150004 	tst	r5, #4                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (                   
  States_Control states_to_clear,                                     
  States_Control current_state                                        
)                                                                     
{                                                                     
   return (current_state & ~states_to_clear);                         
a000bb9c:	03c23004 	biceq	r3, r2, #4                                  <== NOT EXECUTED
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
a000bba0:	05843010 	streq	r3, [r4, #16]                               <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bba4:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
a000bba8:	e3a03bef 	mov	r3, #244736	; 0x3bc00                         <== NOT EXECUTED
a000bbac:	e2833e2e 	add	r3, r3, #736	; 0x2e0                          <== NOT EXECUTED
a000bbb0:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
    _ISR_Enable( level );                                             
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
a000bbb4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000bbb8:	1a000013 	bne	a000bc0c <_Thread_Change_priority+0xbc>       <== NOT EXECUTED
a000bbbc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    }                                                                 
    return;                                                           
  }                                                                   
                                                                      
  /* Only clear the transient state if it wasn't set already */       
  if ( ! _States_Is_transient( original_state ) ) {                   
a000bbc0:	e2155004 	ands	r5, r5, #4                                   <== NOT EXECUTED
a000bbc4:	159f5084 	ldrne	r5, [pc, #132]	; a000bc50 <_Thread_Change_priority+0x100><== NOT EXECUTED
a000bbc8:	0a000013 	beq	a000bc1c <_Thread_Change_priority+0xcc>       <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000bbcc:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a000bbd0:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
a000bbd4:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
 *  This kernel routine implements the scheduling decision logic for  
 *  the scheduler. It does NOT dispatch.                              
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )                 
{                                                                     
  _Scheduler.Operations.schedule();                                   
a000bbd8:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
a000bbdc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
 *  is also the heir thread, and false otherwise.                     
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )  
{                                                                     
  return ( _Thread_Executing == _Thread_Heir );                       
a000bbe0:	e59f306c 	ldr	r3, [pc, #108]	; a000bc54 <_Thread_Change_priority+0x104><== NOT EXECUTED
a000bbe4:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
   *  We altered the set of thread priorities.  So let's figure out   
   *  who is the heir and if we need to switch to them.               
   */                                                                 
  _Scheduler_Schedule();                                              
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
a000bbe8:	e5931008 	ldr	r1, [r3, #8]                                  <== NOT EXECUTED
a000bbec:	e1520001 	cmp	r2, r1                                        <== NOT EXECUTED
a000bbf0:	0a000003 	beq	a000bc04 <_Thread_Change_priority+0xb4>       <== NOT EXECUTED
a000bbf4:	e5d22074 	ldrb	r2, [r2, #116]	; 0x74                        <== NOT EXECUTED
a000bbf8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
a000bbfc:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
a000bc00:	15c32010 	strbne	r2, [r3, #16]                              <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bc04:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
a000bc08:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
a000bc0c:	e5940044 	ldr	r0, [r4, #68]	; 0x44                          <== NOT EXECUTED
a000bc10:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
                                                                      
  if ( !_Thread_Is_executing_also_the_heir() &&                       
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
  _ISR_Enable( level );                                               
}                                                                     
a000bc14:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
a000bc18:	ea0002d2 	b	a000c768 <_Thread_queue_Requeue>                <== NOT EXECUTED
     *  the TRANSIENT state.  So we have to place it on the appropriate
     *  Ready Queue with interrupts off.                              
     */                                                               
    the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
                                                                      
    if ( prepend_it )                                                 
a000bc1c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
     *  Interrupts are STILL disabled.                                
     *  We now know the thread will be in the READY state when we remove
     *  the TRANSIENT state.  So we have to place it on the appropriate
     *  Ready Queue with interrupts off.                              
     */                                                               
    the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
a000bc20:	e5845010 	str	r5, [r4, #16]                                 <== NOT EXECUTED
                                                                      
    if ( prepend_it )                                                 
a000bc24:	0a000004 	beq	a000bc3c <_Thread_Change_priority+0xec>       <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
a000bc28:	e59f5020 	ldr	r5, [pc, #32]	; a000bc50 <_Thread_Change_priority+0x100><== NOT EXECUTED
a000bc2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bc30:	e5953028 	ldr	r3, [r5, #40]	; 0x28                          <== NOT EXECUTED
a000bc34:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000bc38:	eaffffe3 	b	a000bbcc <_Thread_Change_priority+0x7c>         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
a000bc3c:	e59f500c 	ldr	r5, [pc, #12]	; a000bc50 <_Thread_Change_priority+0x100><== NOT EXECUTED
a000bc40:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bc44:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
a000bc48:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000bc4c:	eaffffde 	b	a000bbcc <_Thread_Change_priority+0x7c>         <== NOT EXECUTED
                                                                      

a000bc58 <_Thread_Clear_state>: */ void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) {
a000bc58:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000bc5c:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000bc60:	e3842080 	orr	r2, r4, #128	; 0x80                           <== NOT EXECUTED
a000bc64:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  ISR_Level       level;                                              
  States_Control  current_state;                                      
                                                                      
  _ISR_Disable( level );                                              
    current_state = the_thread->current_state;                        
a000bc68:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
                                                                      
    if ( current_state & state ) {                                    
a000bc6c:	e1110002 	tst	r1, r2                                        <== NOT EXECUTED
a000bc70:	0a000003 	beq	a000bc84 <_Thread_Clear_state+0x2c>           <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (                   
  States_Control states_to_clear,                                     
  States_Control current_state                                        
)                                                                     
{                                                                     
   return (current_state & ~states_to_clear);                         
a000bc74:	e1c22001 	bic	r2, r2, r1                                    <== NOT EXECUTED
      current_state =                                                 
      the_thread->current_state = _States_Clear( state, current_state );
                                                                      
      if ( _States_Is_ready( current_state ) ) {                      
a000bc78:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
  _ISR_Disable( level );                                              
    current_state = the_thread->current_state;                        
                                                                      
    if ( current_state & state ) {                                    
      current_state =                                                 
      the_thread->current_state = _States_Clear( state, current_state );
a000bc7c:	e5802010 	str	r2, [r0, #16]                                 <== NOT EXECUTED
                                                                      
      if ( _States_Is_ready( current_state ) ) {                      
a000bc80:	0a000001 	beq	a000bc8c <_Thread_Clear_state+0x34>           <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bc84:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
        _Scheduler_Unblock( the_thread );                             
      }                                                               
  }                                                                   
  _ISR_Enable( level );                                               
}                                                                     
a000bc88:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(                         
    Thread_Control    *the_thread                                     
)                                                                     
{                                                                     
  _Scheduler.Operations.unblock( the_thread );                        
a000bc8c:	e59f300c 	ldr	r3, [pc, #12]	; a000bca0 <_Thread_Clear_state+0x48><== NOT EXECUTED
a000bc90:	e5933014 	ldr	r3, [r3, #20]                                 <== NOT EXECUTED
a000bc94:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000bc98:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
a000bc9c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000bca4 <_Thread_Close>: RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id( Objects_Information *information, Objects_Control *the_object ) { _Objects_Set_local_object(
a000bca4:	e1d120b8 	ldrh	r2, [r1, #8]                                 <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000bca8:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
                                                                      
void _Thread_Close(                                                   
  Objects_Information  *information,                                  
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
a000bcac:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a000bcb0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
a000bcb4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000bcb8:	e7831102 	str	r1, [r3, r2, lsl #2]                          <== NOT EXECUTED
a000bcbc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
a000bcc0:	e59f608c 	ldr	r6, [pc, #140]	; a000bd54 <_Thread_Close+0xb0><== NOT EXECUTED
   *  disappear and set a transient state on it.  So we temporarily   
   *  unnest dispatching.                                             
   */                                                                 
  _Thread_Unnest_dispatch();                                          
                                                                      
  _User_extensions_Thread_delete( the_thread );                       
a000bcc4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bcc8:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a000bccc:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000bcd0:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
a000bcd4:	eb000401 	bl	a000cce0 <_User_extensions_Thread_delete>      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000bcd8:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a000bcdc:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000bce0:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
  /*                                                                  
   *  Now we are in a dispatching critical section again and we       
   *  can take the thread OUT of the published set.  It is invalid    
   *  to use this thread's Id OR name after this call.                
   */                                                                 
  _Objects_Close( information, &the_thread->Object );                 
a000bce4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000bce8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000bcec:	ebfffc56 	bl	a000ae4c <_Objects_Close>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  By setting the dormant state, the thread will not be considered 
   *  for scheduling when we remove any blocking states.              
   */                                                                 
  _Thread_Set_state( the_thread, STATES_DORMANT );                    
a000bcf0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bcf4:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000bcf8:	eb0002cd 	bl	a000c834 <_Thread_Set_state>                   <== NOT EXECUTED
                                                                      
  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {            
a000bcfc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bd00:	eb000267 	bl	a000c6a4 <_Thread_queue_Extract_with_proxy>    <== NOT EXECUTED
a000bd04:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000bd08:	1a000002 	bne	a000bd18 <_Thread_Close+0x74>                 <== NOT EXECUTED
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
a000bd0c:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000bd10:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a000bd14:	0a00000b 	beq	a000bd48 <_Thread_Close+0xa4>                 <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Free(                            
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.free( the_thread );                    
a000bd18:	e59f3038 	ldr	r3, [pc, #56]	; a000bd58 <_Thread_Close+0xb4> <== NOT EXECUTED
a000bd1c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  /*                                                                  
   *  Free the rest of the memory associated with this task           
   *  and set the associated pointers to NULL for safety.             
   */                                                                 
  _Thread_Stack_Free( the_thread );                                   
  the_thread->Start.stack = NULL;                                     
a000bd20:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a000bd24:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
a000bd28:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Free the rest of the memory associated with this task           
   *  and set the associated pointers to NULL for safety.             
   */                                                                 
  _Thread_Stack_Free( the_thread );                                   
a000bd2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000bd30:	eb0002fb 	bl	a000c924 <_Thread_Stack_Free>                  <== NOT EXECUTED
  the_thread->Start.stack = NULL;                                     
a000bd34:	e58450bc 	str	r5, [r4, #188]	; 0xbc                         <== NOT EXECUTED
                                                                      
  _Workspace_Free( the_thread->extensions );                          
a000bd38:	e59400fc 	ldr	r0, [r4, #252]	; 0xfc                         <== NOT EXECUTED
a000bd3c:	eb0004ff 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
  the_thread->extensions = NULL;                                      
a000bd40:	e58450fc 	str	r5, [r4, #252]	; 0xfc                         <== NOT EXECUTED
}                                                                     
a000bd44:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
   */                                                                 
  _Thread_Set_state( the_thread, STATES_DORMANT );                    
                                                                      
  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {            
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
      (void) _Watchdog_Remove( &the_thread->Timer );                  
a000bd48:	e2840048 	add	r0, r4, #72	; 0x48                            <== NOT EXECUTED
a000bd4c:	eb000488 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a000bd50:	eafffff0 	b	a000bd18 <_Thread_Close+0x74>                   <== NOT EXECUTED
                                                                      

a000be34 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) {
a000be34:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a000be38:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000be3c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000be40:	eb00006b 	bl	a000bff4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000be44:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000be48:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000be4c:	1a000006 	bne	a000be6c <_Thread_Delay_ended+0x38>           <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
a000be50:	e3a01201 	mov	r1, #268435456	; 0x10000000                   <== NOT EXECUTED
a000be54:	e2811018 	add	r1, r1, #24                                   <== NOT EXECUTED
a000be58:	ebffff7e 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
a000be5c:	e59f3010 	ldr	r3, [pc, #16]	; a000be74 <_Thread_Delay_ended+0x40><== NOT EXECUTED
a000be60:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000be64:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a000be68:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
          | STATES_INTERRUPTIBLE_BY_SIGNAL                            
      );                                                              
      _Thread_Unnest_dispatch();                                      
      break;                                                          
  }                                                                   
}                                                                     
a000be6c:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000be70:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000be78 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) {
a000be78:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
a000be7c:	e59f7138 	ldr	r7, [pc, #312]	; a000bfbc <_Thread_Dispatch+0x144>
 *    dispatch thread                                                 
 *    no dispatch thread                                              
 */                                                                   
                                                                      
void _Thread_Dispatch( void )                                         
{                                                                     
a000be80:	e24dd010 	sub	sp, sp, #16                                   
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
a000be84:	e5975004 	ldr	r5, [r7, #4]                                  
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000be88:	e10f2000 	mrs	r2, CPSR                                      
a000be8c:	e3823080 	orr	r3, r2, #128	; 0x80                           
a000be90:	e129f003 	msr	CPSR_fc, r3                                   
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
a000be94:	e5d71010 	ldrb	r1, [r7, #16]                                
a000be98:	e3510000 	cmp	r1, #0                                        
a000be9c:	0a000043 	beq	a000bfb0 <_Thread_Dispatch+0x138>             
    heir = _Thread_Heir;                                              
a000bea0:	e5974008 	ldr	r4, [r7, #8]                                  <== NOT EXECUTED
    _Thread_Dispatch_disable_level = 1;                               
a000bea4:	e59f9114 	ldr	r9, [pc, #276]	; a000bfc0 <_Thread_Dispatch+0x148><== NOT EXECUTED
a000bea8:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    _Thread_Dispatch_necessary = false;                               
a000beac:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
a000beb0:	e1550004 	cmp	r5, r4                                        <== NOT EXECUTED
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
a000beb4:	e5890000 	str	r0, [r9]                                      <== NOT EXECUTED
    _Thread_Dispatch_necessary = false;                               
    _Thread_Executing = heir;                                         
a000beb8:	e5874004 	str	r4, [r7, #4]                                  <== NOT EXECUTED
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
    _Thread_Dispatch_necessary = false;                               
a000bebc:	e5c71010 	strb	r1, [r7, #16]                                <== NOT EXECUTED
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
a000bec0:	01a03002 	moveq	r3, r2                                      <== NOT EXECUTED
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
a000bec4:	0a000033 	beq	a000bf98 <_Thread_Dispatch+0x120>             <== NOT EXECUTED
a000bec8:	e28da008 	add	sl, sp, #8                                    <== NOT EXECUTED
a000becc:	e1a0800d 	mov	r8, sp                                        <== NOT EXECUTED
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
a000bed0:	e1a06007 	mov	r6, r7                                        <== NOT EXECUTED
a000bed4:	ea000007 	b	a000bef8 <_Thread_Dispatch+0x80>                <== NOT EXECUTED
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
a000bed8:	e5964008 	ldr	r4, [r6, #8]                                  <== NOT EXECUTED
    _Thread_Dispatch_disable_level = 1;                               
a000bedc:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    _Thread_Dispatch_necessary = false;                               
a000bee0:	e3a0b000 	mov	fp, #0                                        <== NOT EXECUTED
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
a000bee4:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
    heir = _Thread_Heir;                                              
    _Thread_Dispatch_disable_level = 1;                               
a000bee8:	e5891000 	str	r1, [r9]                                      <== NOT EXECUTED
    _Thread_Dispatch_necessary = false;                               
a000beec:	e5c6b010 	strb	fp, [r6, #16]                                <== NOT EXECUTED
    _Thread_Executing = heir;                                         
a000bef0:	e5864004 	str	r4, [r6, #4]                                  <== NOT EXECUTED
    /*                                                                
     *  When the heir and executing are the same, then we are being   
     *  requested to do the post switch dispatching.  This is normally
     *  done to dispatch signals.                                     
     */                                                               
    if ( heir == executing )                                          
a000bef4:	0a000027 	beq	a000bf98 <_Thread_Dispatch+0x120>             <== NOT EXECUTED
     */                                                               
#if __RTEMS_ADA__                                                     
    executing->rtems_ada_self = rtems_ada_self;                       
    rtems_ada_self = heir->rtems_ada_self;                            
#endif                                                                
    if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
a000bef8:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a000befc:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
a000bf00:	059fc0bc 	ldreq	ip, [pc, #188]	; a000bfc4 <_Thread_Dispatch+0x14c><== NOT EXECUTED
a000bf04:	059c3000 	ldreq	r3, [ip]                                    <== NOT EXECUTED
a000bf08:	05843078 	streq	r3, [r4, #120]	; 0x78                       <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bf0c:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
a000bf10:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000bf14:	eb000cd2 	bl	a000f264 <_TOD_Get_uptime>                     <== NOT EXECUTED
        _Timestamp_Subtract(                                          
a000bf18:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000bf1c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a000bf20:	e59f00a0 	ldr	r0, [pc, #160]	; a000bfc8 <_Thread_Dispatch+0x150><== NOT EXECUTED
a000bf24:	eb0002e0 	bl	a000caac <_Timespec_Subtract>                  <== NOT EXECUTED
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
a000bf28:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000bf2c:	e2850084 	add	r0, r5, #132	; 0x84                           <== NOT EXECUTED
a000bf30:	eb0002c6 	bl	a000ca50 <_Timespec_Add_to>                    <== NOT EXECUTED
        _Thread_Time_of_last_context_switch = uptime;                 
a000bf34:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
a000bf38:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
a000bf3c:	e59f2088 	ldr	r2, [pc, #136]	; a000bfcc <_Thread_Dispatch+0x154><== NOT EXECUTED
      executing->libc_reent = *_Thread_libc_reent;                    
      *_Thread_libc_reent = heir->libc_reent;                         
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
a000bf40:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000bf44:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
a000bf48:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
        _Thread_Time_of_last_context_switch = uptime;                 
a000bf4c:	e59f2074 	ldr	r2, [pc, #116]	; a000bfc8 <_Thread_Dispatch+0x150><== NOT EXECUTED
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
a000bf50:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
        _Thread_Time_of_last_context_switch = uptime;                 
a000bf54:	e8821800 	stm	r2, {fp, ip}                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
      executing->libc_reent = *_Thread_libc_reent;                    
a000bf58:	15932000 	ldrne	r2, [r3]                                    <== NOT EXECUTED
a000bf5c:	158520f0 	strne	r2, [r5, #240]	; 0xf0                       <== NOT EXECUTED
      *_Thread_libc_reent = heir->libc_reent;                         
a000bf60:	159420f0 	ldrne	r2, [r4, #240]	; 0xf0                       <== NOT EXECUTED
a000bf64:	15832000 	strne	r2, [r3]                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    _User_extensions_Thread_switch( executing, heir );                
a000bf68:	eb000382 	bl	a000cd78 <_User_extensions_Thread_switch>      <== NOT EXECUTED
    if ( executing->fp_context != NULL )                              
      _Context_Save_fp( &executing->fp_context );                     
#endif                                                                
#endif                                                                
                                                                      
    _Context_Switch( &executing->Registers, &heir->Registers );       
a000bf6c:	e28500c0 	add	r0, r5, #192	; 0xc0                           <== NOT EXECUTED
a000bf70:	e28410c0 	add	r1, r4, #192	; 0xc0                           <== NOT EXECUTED
a000bf74:	eb000551 	bl	a000d4c0 <_CPU_Context_switch>                 <== NOT EXECUTED
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
a000bf78:	e5975004 	ldr	r5, [r7, #4]                                  <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000bf7c:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a000bf80:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a000bf84:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
a000bf88:	e5d71010 	ldrb	r1, [r7, #16]                                <== NOT EXECUTED
a000bf8c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000bf90:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000bf94:	1affffcf 	bne	a000bed8 <_Thread_Dispatch+0x60>              <== NOT EXECUTED
                                                                      
    _ISR_Disable( level );                                            
  }                                                                   
                                                                      
post_switch:                                                          
  _Thread_Dispatch_disable_level = 0;                                 
a000bf98:	e3a01000 	mov	r1, #0                                        
a000bf9c:	e5891000 	str	r1, [r9]                                      
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000bfa0:	e129f003 	msr	CPSR_fc, r3                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
  _API_extensions_Run_postswitch();                                   
a000bfa4:	ebfff8be 	bl	a000a2a4 <_API_extensions_Run_postswitch>      
}                                                                     
a000bfa8:	e28dd010 	add	sp, sp, #16                                   
a000bfac:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
  Thread_Control   *executing;                                        
  Thread_Control   *heir;                                             
  ISR_Level         level;                                            
                                                                      
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
a000bfb0:	e1a03002 	mov	r3, r2                                        
a000bfb4:	e59f9004 	ldr	r9, [pc, #4]	; a000bfc0 <_Thread_Dispatch+0x148>
a000bfb8:	eafffff6 	b	a000bf98 <_Thread_Dispatch+0x120>               
                                                                      

a000bff4 <_Thread_Get>: uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
a000bff4:	e2503000 	subs	r3, r0, #0                                   
 */                                                                   
Thread_Control *_Thread_Get (                                         
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
a000bff8:	e1a02001 	mov	r2, r1                                        
  uint32_t             the_class;                                     
  Objects_Information **api_information;                              
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {           
a000bffc:	0a000014 	beq	a000c054 <_Thread_Get+0x60>                   
 */                                                                   
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(                   
  Objects_Id id                                                       
)                                                                     
{                                                                     
  return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
a000c000:	e1a01c23 	lsr	r1, r3, #24                                   
a000c004:	e2011007 	and	r1, r1, #7                                    
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(                      
  uint32_t   the_api                                                  
)                                                                     
{                                                                     
  if ( !the_api || the_api > OBJECTS_APIS_LAST )                      
a000c008:	e2410001 	sub	r0, r1, #1                                    
a000c00c:	e3500002 	cmp	r0, #2                                        
a000c010:	8a00000b 	bhi	a000c044 <_Thread_Get+0x50>                   
 */                                                                   
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(                     
  Objects_Id id                                                       
)                                                                     
{                                                                     
  return (uint32_t)                                                   
a000c014:	e1a0cda3 	lsr	ip, r3, #27                                   
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
a000c018:	e35c0001 	cmp	ip, #1                                        
a000c01c:	1a000008 	bne	a000c044 <_Thread_Get+0x50>                   
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  api_information = _Objects_Information_table[ the_api ];            
a000c020:	e59f0054 	ldr	r0, [pc, #84]	; a000c07c <_Thread_Get+0x88>   
a000c024:	e7900101 	ldr	r0, [r0, r1, lsl #2]                          
   *  There is no way for this to happen if POSIX is enabled.  But there
   *  is actually a test case in sp43 for this which trips it whether or
   *  not POSIX is enabled.  So in the interest of safety, this is left
   *  on in all configurations.                                       
   */                                                                 
  if ( !api_information ) {                                           
a000c028:	e3500000 	cmp	r0, #0                                        
a000c02c:	0a000010 	beq	a000c074 <_Thread_Get+0x80>                   
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  information = api_information[ the_class ];                         
a000c030:	e5900004 	ldr	r0, [r0, #4]                                  
  if ( !information ) {                                               
a000c034:	e3500000 	cmp	r0, #0                                        
a000c038:	0a00000d 	beq	a000c074 <_Thread_Get+0x80>                   
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
  }                                                                   
                                                                      
  tp = (Thread_Control *) _Objects_Get( information, id, location );  
a000c03c:	e1a01003 	mov	r1, r3                                        
a000c040:	eafffc8f 	b	a000b284 <_Objects_Get>                         
    goto done;                                                        
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
    *location = OBJECTS_ERROR;                                        
a000c044:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000c048:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
{                                                                     
  uint32_t             the_api;                                       
  uint32_t             the_class;                                     
  Objects_Information **api_information;                              
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
a000c04c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  the_class = _Objects_Get_class( id );                               
  if ( the_class != 1 ) {       /* threads are always first class :) */
    *location = OBJECTS_ERROR;                                        
    goto done;                                                        
a000c050:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000c054:	e59f1024 	ldr	r1, [pc, #36]	; a000c080 <_Thread_Get+0x8c>   <== NOT EXECUTED
a000c058:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
a000c05c:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a000c060:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
  Objects_Information *information;                                   
  Thread_Control      *tp = (Thread_Control *) 0;                     
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {           
    _Thread_Disable_dispatch();                                       
    *location = OBJECTS_LOCAL;                                        
a000c064:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    tp = _Thread_Executing;                                           
a000c068:	e59f3014 	ldr	r3, [pc, #20]	; a000c084 <_Thread_Get+0x90>   <== NOT EXECUTED
a000c06c:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
    goto done;                                                        
a000c070:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    goto done;                                                        
  }                                                                   
                                                                      
  information = api_information[ the_class ];                         
  if ( !information ) {                                               
    *location = OBJECTS_ERROR;                                        
a000c074:	e582c000 	str	ip, [r2]                                      <== NOT EXECUTED
    goto done;                                                        
a000c078:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010f78 <_Thread_Handler>: #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing;
a0010f78:	e59f3078 	ldr	r3, [pc, #120]	; a0010ff8 <_Thread_Handler+0x80>
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Handler( void )                                          
{                                                                     
a0010f7c:	e92d4030 	push	{r4, r5, lr}                                 
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static char doneConstructors;                                     
    char doneCons;                                                    
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
a0010f80:	e5934004 	ldr	r4, [r3, #4]                                  
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
                                                                      
  level = executing->Start.isr_level;                                 
a0010f84:	e59400ac 	ldr	r0, [r4, #172]	; 0xac                         
  _ISR_Set_level(level);                                              
a0010f88:	ebfff15d 	bl	a000d504 <_CPU_ISR_Set_level>                  
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
a0010f8c:	e59f3068 	ldr	r3, [pc, #104]	; a0010ffc <_Thread_Handler+0x84>
    doneConstructors = 1;                                             
a0010f90:	e3a02001 	mov	r2, #1                                        
  /*                                                                  
   * Take care that 'begin' extensions get to complete before         
   * 'switch' extensions can run.  This means must keep dispatch      
   * disabled until all 'begin' extensions complete.                  
   */                                                                 
  _User_extensions_Thread_begin( executing );                         
a0010f94:	e1a00004 	mov	r0, r4                                        
                                                                      
  level = executing->Start.isr_level;                                 
  _ISR_Set_level(level);                                              
                                                                      
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    doneCons = doneConstructors;                                      
a0010f98:	e5d35000 	ldrb	r5, [r3]                                     
    doneConstructors = 1;                                             
a0010f9c:	e5c32000 	strb	r2, [r3]                                     
  /*                                                                  
   * Take care that 'begin' extensions get to complete before         
   * 'switch' extensions can run.  This means must keep dispatch      
   * disabled until all 'begin' extensions complete.                  
   */                                                                 
  _User_extensions_Thread_begin( executing );                         
a0010fa0:	ebffef02 	bl	a000cbb0 <_User_extensions_Thread_begin>       
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
a0010fa4:	ebffec09 	bl	a000bfd0 <_Thread_Enable_dispatch>             
    /*                                                                
     *  _init could be a weak symbol and we SHOULD test it but it isn't
     *  in any configuration I know of and it generates a warning on every
     *  RTEMS target configuration.  --joel (12 May 2007)             
     */                                                               
    if (!doneCons) /* && (volatile void *)_init) */ {                 
a0010fa8:	e3550000 	cmp	r5, #0                                        
a0010fac:	0a000008 	beq	a0010fd4 <_Thread_Handler+0x5c>               
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
a0010fb0:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
a0010fb4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010fb8:	0a000009 	beq	a0010fe4 <_Thread_Handler+0x6c>               <== NOT EXECUTED
   *  was placed in return_argument.  This assumed that if it returned
   *  anything (which is not supporting in all APIs), then it would be
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
a0010fbc:	e1a00004 	mov	r0, r4                                        
a0010fc0:	ebffef0a 	bl	a000cbf0 <_User_extensions_Thread_exitted>     
                                                                      
  _Internal_error_Occurred(                                           
a0010fc4:	e3a00000 	mov	r0, #0                                        
a0010fc8:	e3a01001 	mov	r1, #1                                        
a0010fcc:	e3a02005 	mov	r2, #5                                        
a0010fd0:	ebffe760 	bl	a000ad58 <_Internal_error_Occurred>            
     *  _init could be a weak symbol and we SHOULD test it but it isn't
     *  in any configuration I know of and it generates a warning on every
     *  RTEMS target configuration.  --joel (12 May 2007)             
     */                                                               
    if (!doneCons) /* && (volatile void *)_init) */ {                 
      INIT_NAME ();                                                   
a0010fd4:	ebffcd79 	bl	a00045c0 <bsp_section_text_load_begin>         
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
a0010fd8:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         
a0010fdc:	e3530000 	cmp	r3, #0                                        
a0010fe0:	1afffff5 	bne	a0010fbc <_Thread_Handler+0x44>               
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
a0010fe4:	e5943090 	ldr	r3, [r4, #144]	; 0x90                         
a0010fe8:	e594009c 	ldr	r0, [r4, #156]	; 0x9c                         
a0010fec:	e12fff33 	blx	r3                                            
      INIT_NAME ();                                                   
    }                                                                 
  #endif                                                              
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
a0010ff0:	e5840028 	str	r0, [r4, #40]	; 0x28                          
a0010ff4:	eafffff0 	b	a0010fbc <_Thread_Handler+0x44>                 
                                                                      

a000c228 <_Thread_Handler_initialization>: uint32_t maximum_internal_threads; #if defined(RTEMS_MULTIPROCESSING) uint32_t maximum_proxies; #endif ticks_per_timeslice = Configuration.ticks_per_timeslice;
a000c228:	e59f2088 	ldr	r2, [pc, #136]	; a000c2b8 <_Thread_Handler_initialization+0x90>
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Handler_initialization(void)                             
{                                                                     
a000c22c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  #endif                                                              
  /*                                                                  
   * BOTH stacks hooks must be set or both must be NULL.              
   * Do not allow mixture.                                            
   */                                                                 
    if ( !( (!Configuration.stack_allocate_hook)                      
a000c230:	e592c020 	ldr	ip, [r2, #32]                                 
            == (!Configuration.stack_free_hook) ) )                   
a000c234:	e5921024 	ldr	r1, [r2, #36]	; 0x24                          
  uint32_t     maximum_internal_threads;                              
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t   maximum_proxies;                                       
  #endif                                                              
                                                                      
  ticks_per_timeslice = Configuration.ticks_per_timeslice;            
a000c238:	e5923010 	ldr	r3, [r2, #16]                                 
  #endif                                                              
  /*                                                                  
   * BOTH stacks hooks must be set or both must be NULL.              
   * Do not allow mixture.                                            
   */                                                                 
    if ( !( (!Configuration.stack_allocate_hook)                      
a000c23c:	e27cc001 	rsbs	ip, ip, #1                                   
a000c240:	33a0c000 	movcc	ip, #0                                      
a000c244:	e3510000 	cmp	r1, #0                                        
a000c248:	022cc001 	eoreq	ip, ip, #1                                  
a000c24c:	e35c0000 	cmp	ip, #0                                        
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Handler_initialization(void)                             
{                                                                     
a000c250:	e24dd00c 	sub	sp, sp, #12                                   
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t   maximum_proxies;                                       
  #endif                                                              
                                                                      
  ticks_per_timeslice = Configuration.ticks_per_timeslice;            
  maximum_extensions  = Configuration.maximum_extensions;             
a000c254:	e5922008 	ldr	r2, [r2, #8]                                  
  #endif                                                              
  /*                                                                  
   * BOTH stacks hooks must be set or both must be NULL.              
   * Do not allow mixture.                                            
   */                                                                 
    if ( !( (!Configuration.stack_allocate_hook)                      
a000c258:	1a000012 	bne	a000c2a8 <_Thread_Handler_initialization+0x80>
      INTERNAL_ERROR_CORE,                                            
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  _Thread_Dispatch_necessary = false;                                 
a000c25c:	e59fe058 	ldr	lr, [pc, #88]	; a000c2bc <_Thread_Handler_initialization+0x94>
  _Thread_Heir              = NULL;                                   
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  _Thread_Allocated_fp      = NULL;                                   
#endif                                                                
                                                                      
  _Thread_Maximum_extensions = maximum_extensions;                    
a000c260:	e59f0058 	ldr	r0, [pc, #88]	; a000c2c0 <_Thread_Handler_initialization+0x98>
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
a000c264:	e3a01001 	mov	r1, #1                                        
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  _Thread_Dispatch_necessary = false;                                 
  _Thread_Executing         = NULL;                                   
a000c268:	e58ec004 	str	ip, [lr, #4]                                  
  _Thread_Heir              = NULL;                                   
a000c26c:	e58ec008 	str	ip, [lr, #8]                                  
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  _Thread_Allocated_fp      = NULL;                                   
#endif                                                                
                                                                      
  _Thread_Maximum_extensions = maximum_extensions;                    
a000c270:	e5802000 	str	r2, [r0]                                      
                                                                      
  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;                 
a000c274:	e59f2048 	ldr	r2, [pc, #72]	; a000c2c4 <_Thread_Handler_initialization+0x9c>
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
a000c278:	e59f0048 	ldr	r0, [pc, #72]	; a000c2c8 <_Thread_Handler_initialization+0xa0>
  _Thread_Allocated_fp      = NULL;                                   
#endif                                                                
                                                                      
  _Thread_Maximum_extensions = maximum_extensions;                    
                                                                      
  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;                 
a000c27c:	e5823000 	str	r3, [r2]                                      
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
a000c280:	e3a03f41 	mov	r3, #260	; 0x104                              
a000c284:	e88d1008 	stm	sp, {r3, ip}                                  
a000c288:	e1a02001 	mov	r2, r1                                        
      INTERNAL_ERROR_CORE,                                            
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  _Thread_Dispatch_necessary = false;                                 
a000c28c:	e5cec010 	strb	ip, [lr, #16]                                
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
a000c290:	e1a03001 	mov	r3, r1                                        
a000c294:	e3a0c008 	mov	ip, #8                                        
a000c298:	e58dc008 	str	ip, [sp, #8]                                  
a000c29c:	ebfffc18 	bl	a000b304 <_Objects_Initialize_information>     
      false,                      /* true if this is a global object class */
      NULL                        /* Proxy extraction support callout */
    #endif                                                            
  );                                                                  
                                                                      
}                                                                     
a000c2a0:	e28dd00c 	add	sp, sp, #12                                   
a000c2a4:	e8bd8000 	pop	{pc}                                          
   * BOTH stacks hooks must be set or both must be NULL.              
   * Do not allow mixture.                                            
   */                                                                 
    if ( !( (!Configuration.stack_allocate_hook)                      
            == (!Configuration.stack_free_hook) ) )                   
    _Internal_error_Occurred(                                         
a000c2a8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000c2ac:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000c2b0:	e3a0200e 	mov	r2, #14                                       <== NOT EXECUTED
a000c2b4:	ebfffaa7 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a000c088 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
a000c088:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
                                                                      
  /*                                                                  
   *  Zero out all the allocated memory fields                        
   */                                                                 
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    the_thread->API_Extensions[i] = NULL;                             
a000c08c:	e3a05000 	mov	r5, #0                                        
a000c090:	e58150f4 	str	r5, [r1, #244]	; 0xf4                         
a000c094:	e58150f8 	str	r5, [r1, #248]	; 0xf8                         
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
a000c098:	e58150f0 	str	r5, [r1, #240]	; 0xf0                         
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
a000c09c:	e1a04001 	mov	r4, r1                                        
a000c0a0:	e1a0a000 	mov	sl, r0                                        
                                                                      
  /*                                                                  
   *  Allocate and Initialize the stack for this thread.              
   */                                                                 
  #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) 
    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
a000c0a4:	e1a00001 	mov	r0, r1                                        
a000c0a8:	e1a01003 	mov	r1, r3                                        
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
a000c0ac:	e1a06003 	mov	r6, r3                                        
a000c0b0:	e59d7024 	ldr	r7, [sp, #36]	; 0x24                          
a000c0b4:	e5dd8028 	ldrb	r8, [sp, #40]	; 0x28                         
                                                                      
  /*                                                                  
   *  Allocate and Initialize the stack for this thread.              
   */                                                                 
  #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) 
    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
a000c0b8:	eb0001fe 	bl	a000c8b8 <_Thread_Stack_Allocate>              
    if ( !actual_stack_size || actual_stack_size < stack_size )       
a000c0bc:	e1500005 	cmp	r0, r5                                        
a000c0c0:	13a03000 	movne	r3, #0                                      
a000c0c4:	03a03001 	moveq	r3, #1                                      
a000c0c8:	e1500006 	cmp	r0, r6                                        
a000c0cc:	21a06003 	movcs	r6, r3                                      
a000c0d0:	33836001 	orrcc	r6, r3, #1                                  
a000c0d4:	e1560005 	cmp	r6, r5                                        
a000c0d8:	1a00003b 	bne	a000c1cc <_Thread_Initialize+0x144>           
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
a000c0dc:	e59f913c 	ldr	r9, [pc, #316]	; a000c220 <_Thread_Initialize+0x198>
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
a000c0e0:	e59430bc 	ldr	r3, [r4, #188]	; 0xbc                         
  the_stack->size = size;                                             
a000c0e4:	e58400b4 	str	r0, [r4, #180]	; 0xb4                         
a000c0e8:	e5995000 	ldr	r5, [r9]                                      
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
a000c0ec:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000c0f0:	e5846050 	str	r6, [r4, #80]	; 0x50                          
a000c0f4:	e3550000 	cmp	r5, #0                                        
  the_watchdog->routine   = routine;                                  
a000c0f8:	e5846064 	str	r6, [r4, #100]	; 0x64                         
  the_watchdog->id        = id;                                       
a000c0fc:	e5846068 	str	r6, [r4, #104]	; 0x68                         
  the_watchdog->user_data = user_data;                                
a000c100:	e584606c 	str	r6, [r4, #108]	; 0x6c                         
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
a000c104:	058450fc 	streq	r5, [r4, #252]	; 0xfc                       
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
a000c108:	1a000031 	bne	a000c1d4 <_Thread_Initialize+0x14c>           
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
a000c10c:	e59d302c 	ldr	r3, [sp, #44]	; 0x2c                          
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
a000c110:	e3a06000 	mov	r6, #0                                        
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
a000c114:	e3a09001 	mov	r9, #1                                        
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
a000c118:	e58430a4 	str	r3, [r4, #164]	; 0xa4                         
  the_thread->Start.budget_callout   = budget_callout;                
a000c11c:	e59d3030 	ldr	r3, [sp, #48]	; 0x30                          
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
a000c120:	e5c480a0 	strb	r8, [r4, #160]	; 0xa0                        
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
a000c124:	e5849010 	str	r9, [r4, #16]                                 
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
a000c128:	e58430a8 	str	r3, [r4, #168]	; 0xa8                         
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
a000c12c:	e59d3034 	ldr	r3, [sp, #52]	; 0x34                          
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
a000c130:	e5846044 	str	r6, [r4, #68]	; 0x44                          
  the_thread->resource_count          = 0;                            
a000c134:	e584601c 	str	r6, [r4, #28]                                 
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
a000c138:	e58430ac 	str	r3, [r4, #172]	; 0xac                         
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
a000c13c:	e59f30e0 	ldr	r3, [pc, #224]	; a000c224 <_Thread_Initialize+0x19c>
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
  the_thread->real_priority           = priority;                     
a000c140:	e5847018 	str	r7, [r4, #24]                                 
  the_thread->Start.initial_priority  = priority;                     
a000c144:	e58470b0 	str	r7, [r4, #176]	; 0xb0                         
a000c148:	e5933018 	ldr	r3, [r3, #24]                                 
a000c14c:	e1a00004 	mov	r0, r4                                        
a000c150:	e12fff33 	blx	r3                                            
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
a000c154:	e2508000 	subs	r8, r0, #0                                   
a000c158:	0a00000d 	beq	a000c194 <_Thread_Initialize+0x10c>           
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
a000c15c:	e1a00004 	mov	r0, r4                                        
a000c160:	e1a01007 	mov	r1, r7                                        
a000c164:	eb0001ab 	bl	a000c818 <_Thread_Set_priority>                
                                                                      
   _Workspace_Free( sched );                                          
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
}                                                                     
a000c168:	e59a301c 	ldr	r3, [sl, #28]                                 
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a000c16c:	e1d420b8 	ldrh	r2, [r4, #8]                                 
                                                                      
  /*                                                                  
   *  Initialize the CPU usage statistics                             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &the_thread->cpu_time_used );             
a000c170:	e5846084 	str	r6, [r4, #132]	; 0x84                         
a000c174:	e5846088 	str	r6, [r4, #136]	; 0x88                         
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000c178:	e7834102 	str	r4, [r3, r2, lsl #2]                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a000c17c:	e59d3038 	ldr	r3, [sp, #56]	; 0x38                          
   *  enabled when we get here.  We want to be able to run the        
   *  user extensions with dispatching enabled.  The Allocator        
   *  Mutex provides sufficient protection to let the user extensions 
   *  run safely.                                                     
   */                                                                 
  extension_status = _User_extensions_Thread_create( the_thread );    
a000c180:	e1a00004 	mov	r0, r4                                        
a000c184:	e584300c 	str	r3, [r4, #12]                                 
a000c188:	eb0002bc 	bl	a000cc80 <_User_extensions_Thread_create>      
  if ( extension_status )                                             
a000c18c:	e1500006 	cmp	r0, r6                                        
a000c190:	1a00001e 	bne	a000c210 <_Thread_Initialize+0x188>           
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
a000c194:	e59400f0 	ldr	r0, [r4, #240]	; 0xf0                         <== NOT EXECUTED
a000c198:	eb0003e8 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
a000c19c:	e59400f4 	ldr	r0, [r4, #244]	; 0xf4                         <== NOT EXECUTED
a000c1a0:	eb0003e6 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
a000c1a4:	e59400f8 	ldr	r0, [r4, #248]	; 0xf8                         <== NOT EXECUTED
a000c1a8:	eb0003e4 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
                                                                      
  _Workspace_Free( extensions_area );                                 
a000c1ac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000c1b0:	eb0003e2 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
a000c1b4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000c1b8:	eb0003e0 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
                                                                      
   _Thread_Stack_Free( the_thread );                                  
a000c1bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000c1c0:	eb0001d7 	bl	a000c924 <_Thread_Stack_Free>                  <== NOT EXECUTED
  return false;                                                       
a000c1c4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000c1c8:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
   *  Allocate and Initialize the stack for this thread.              
   */                                                                 
  #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) 
    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
    if ( !actual_stack_size || actual_stack_size < stack_size )       
      return false;                     /* stack allocation failed */ 
a000c1cc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000c1d0:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
    extensions_area = _Workspace_Allocate(                            
a000c1d4:	e2855001 	add	r5, r5, #1                                    
a000c1d8:	e1a00105 	lsl	r0, r5, #2                                    
a000c1dc:	eb0003d1 	bl	a000d128 <_Workspace_Allocate>                 
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
a000c1e0:	e2505000 	subs	r5, r0, #0                                   
a000c1e4:	0a00000b 	beq	a000c218 <_Thread_Initialize+0x190>           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
a000c1e8:	e5991000 	ldr	r1, [r9]                                      
a000c1ec:	e58450fc 	str	r5, [r4, #252]	; 0xfc                         
a000c1f0:	e1a03006 	mov	r3, r6                                        
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
      the_thread->extensions[i] = NULL;                               
a000c1f4:	e1a02006 	mov	r2, r6                                        
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
a000c1f8:	e2833001 	add	r3, r3, #1                                    
a000c1fc:	e1530001 	cmp	r3, r1                                        
      the_thread->extensions[i] = NULL;                               
a000c200:	e7852106 	str	r2, [r5, r6, lsl #2]                          
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
    for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )              
a000c204:	e1a06003 	mov	r6, r3                                        
a000c208:	9afffffa 	bls	a000c1f8 <_Thread_Initialize+0x170>           
a000c20c:	eaffffbe 	b	a000c10c <_Thread_Initialize+0x84>              
   *  Mutex provides sufficient protection to let the user extensions 
   *  run safely.                                                     
   */                                                                 
  extension_status = _User_extensions_Thread_create( the_thread );    
  if ( extension_status )                                             
    return true;                                                      
a000c210:	e1a00009 	mov	r0, r9                                        
                                                                      
   _Workspace_Free( sched );                                          
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
}                                                                     
a000c214:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              
  size_t               actual_stack_size = 0;                         
  void                *stack = NULL;                                  
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    void              *fp_area;                                       
  #endif                                                              
  void                *sched = NULL;                                  
a000c218:	e1a08005 	mov	r8, r5                                        <== NOT EXECUTED
a000c21c:	eaffffdc 	b	a000c194 <_Thread_Initialize+0x10c>             <== NOT EXECUTED
                                                                      

a0010838 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) {
a0010838:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  the_thread->resource_count   = 0;                                   
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
a001083c:	e590c0a4 	ldr	ip, [r0, #164]	; 0xa4                         <== NOT EXECUTED
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
  the_thread->resource_count   = 0;                                   
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
a0010840:	e5d0e0a0 	ldrb	lr, [r0, #160]	; 0xa0                        <== NOT EXECUTED
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
a0010844:	e59030a8 	ldr	r3, [r0, #168]	; 0xa8                         <== NOT EXECUTED
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
  the_thread->resource_count   = 0;                                   
a0010848:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a001084c:	e580501c 	str	r5, [r0, #28]                                 <== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
a0010850:	e5c0e074 	strb	lr, [r0, #116]	; 0x74                        <== NOT EXECUTED
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
a0010854:	e580c07c 	str	ip, [r0, #124]	; 0x7c                         <== NOT EXECUTED
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
a0010858:	e5803080 	str	r3, [r0, #128]	; 0x80                         <== NOT EXECUTED
                                                                      
  the_thread->Start.pointer_argument = pointer_argument;              
a001085c:	e5801098 	str	r1, [r0, #152]	; 0x98                         <== NOT EXECUTED
  the_thread->Start.numeric_argument = numeric_argument;              
a0010860:	e580209c 	str	r2, [r0, #156]	; 0x9c                         <== NOT EXECUTED
void _Thread_Reset(                                                   
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
a0010864:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
                                                                      
  the_thread->Start.pointer_argument = pointer_argument;              
  the_thread->Start.numeric_argument = numeric_argument;              
                                                                      
  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {            
a0010868:	ebfff2d3 	bl	a000d3bc <_Thread_queue_Extract_with_proxy>    <== NOT EXECUTED
a001086c:	e1500005 	cmp	r0, r5                                        <== NOT EXECUTED
a0010870:	1a000002 	bne	a0010880 <_Thread_Reset+0x48>                 <== NOT EXECUTED
                                                                      
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
a0010874:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0010878:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a001087c:	0a000008 	beq	a00108a4 <_Thread_Reset+0x6c>                 <== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );                  
  }                                                                   
                                                                      
  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
a0010880:	e59410b0 	ldr	r1, [r4, #176]	; 0xb0                         <== NOT EXECUTED
a0010884:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a0010888:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a001088c:	0a000003 	beq	a00108a0 <_Thread_Reset+0x68>                 <== NOT EXECUTED
    the_thread->real_priority = the_thread->Start.initial_priority;   
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
a0010890:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
      (void) _Watchdog_Remove( &the_thread->Timer );                  
  }                                                                   
                                                                      
  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
    the_thread->real_priority = the_thread->Start.initial_priority;   
a0010894:	e5841018 	str	r1, [r4, #24]                                 <== NOT EXECUTED
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
  }                                                                   
}                                                                     
a0010898:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );                  
  }                                                                   
                                                                      
  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
    the_thread->real_priority = the_thread->Start.initial_priority;   
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
a001089c:	eafff340 	b	a000d5a4 <_Thread_Set_priority>                 <== NOT EXECUTED
a00108a0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  the_thread->Start.numeric_argument = numeric_argument;              
                                                                      
  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {            
                                                                      
    if ( _Watchdog_Is_active( &the_thread->Timer ) )                  
      (void) _Watchdog_Remove( &the_thread->Timer );                  
a00108a4:	e2840048 	add	r0, r4, #72	; 0x48                            <== NOT EXECUTED
a00108a8:	ebfff527 	bl	a000dd4c <_Watchdog_Remove>                    <== NOT EXECUTED
a00108ac:	eafffff3 	b	a0010880 <_Thread_Reset+0x48>                   <== NOT EXECUTED
                                                                      

a000d530 <_Thread_Restart>: */ RTEMS_INLINE_ROUTINE bool _States_Is_dormant ( States_Control the_states ) { return (the_states & STATES_DORMANT);
a000d530:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
bool _Thread_Restart(                                                 
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
a000d534:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
a000d538:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
bool _Thread_Restart(                                                 
  Thread_Control            *the_thread,                              
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
a000d53c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000d540:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a000d544:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
a000d548:	0a000001 	beq	a000d554 <_Thread_Restart+0x24>               <== NOT EXECUTED
      _Thread_Restart_self();                                         
                                                                      
    return true;                                                      
  }                                                                   
                                                                      
  return false;                                                       
a000d54c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000d550:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
  if ( !_States_Is_dormant( the_thread->current_state ) ) {           
                                                                      
    _Thread_Set_transient( the_thread );                              
a000d554:	eb00002b 	bl	a000d608 <_Thread_Set_transient>               <== NOT EXECUTED
                                                                      
    _Thread_Reset( the_thread, pointer_argument, numeric_argument );  
a000d558:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000d55c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000d560:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d564:	eb000cb3 	bl	a0010838 <_Thread_Reset>                       <== NOT EXECUTED
                                                                      
    _Thread_Load_environment( the_thread );                           
a000d568:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d56c:	eb000bff 	bl	a0010570 <_Thread_Load_environment>            <== NOT EXECUTED
                                                                      
    _Thread_Ready( the_thread );                                      
a000d570:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d574:	eb000ca3 	bl	a0010808 <_Thread_Ready>                       <== NOT EXECUTED
                                                                      
    _User_extensions_Thread_restart( the_thread );                    
a000d578:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d57c:	eb00014d 	bl	a000dab8 <_User_extensions_Thread_restart>     <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
a000d580:	e59f3018 	ldr	r3, [pc, #24]	; a000d5a0 <_Thread_Restart+0x70><== NOT EXECUTED
                                                                      
    if ( _Thread_Is_executing ( the_thread ) )                        
a000d584:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000d588:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000d58c:	0a000001 	beq	a000d598 <_Thread_Restart+0x68>               <== NOT EXECUTED
      _Thread_Restart_self();                                         
                                                                      
    return true;                                                      
a000d590:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return false;                                                       
}                                                                     
a000d594:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  if ( _Thread_Executing->fp_context != NULL )                        
    _Context_Restore_fp( &_Thread_Executing->fp_context );            
#endif                                                                
                                                                      
  _CPU_Context_Restart_self( &_Thread_Executing->Registers );         
a000d598:	e28400c0 	add	r0, r4, #192	; 0xc0                           <== NOT EXECUTED
a000d59c:	eb000342 	bl	a000e2ac <_CPU_Context_restore>                <== NOT EXECUTED
                                                                      

a000c834 <_Thread_Set_state>: */ void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) {
a000c834:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c838:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000c83c:	e3842080 	orr	r2, r4, #128	; 0x80                           <== NOT EXECUTED
a000c840:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  ISR_Level      level;                                               
                                                                      
  _ISR_Disable( level );                                              
  if ( !_States_Is_ready( the_thread->current_state ) ) {             
a000c844:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
a000c848:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000c84c:	0a000003 	beq	a000c860 <_Thread_Set_state+0x2c>             <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Set (                     
  States_Control states_to_set,                                       
  States_Control current_state                                        
)                                                                     
{                                                                     
   return (current_state | states_to_set);                            
a000c850:	e1812002 	orr	r2, r1, r2                                    <== NOT EXECUTED
    the_thread->current_state =                                       
a000c854:	e5802010 	str	r2, [r0, #16]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c858:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
a000c85c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Block(                           
    Thread_Control    *the_thread                                     
)                                                                     
{                                                                     
  _Scheduler.Operations.block( the_thread );                          
a000c860:	e59f3010 	ldr	r3, [pc, #16]	; a000c878 <_Thread_Set_state+0x44><== NOT EXECUTED
       _States_Set( state, the_thread->current_state );               
    _ISR_Enable( level );                                             
    return;                                                           
  }                                                                   
                                                                      
  the_thread->current_state = state;                                  
a000c864:	e5801010 	str	r1, [r0, #16]                                 <== NOT EXECUTED
a000c868:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000c86c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000c870:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
a000c874:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000c87c <_Thread_Set_transient>: * only case */ void _Thread_Set_transient( Thread_Control *the_thread ) {
a000c87c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c880:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000c884:	e3842080 	orr	r2, r4, #128	; 0x80                           <== NOT EXECUTED
a000c888:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  ISR_Level             level;                                        
  uint32_t              old_state;                                    
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  old_state = the_thread->current_state;                              
a000c88c:	e5902010 	ldr	r2, [r0, #16]                                 <== NOT EXECUTED
a000c890:	e3821004 	orr	r1, r2, #4                                    <== NOT EXECUTED
  the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
                                                                      
  if ( _States_Is_ready( old_state ) ) {                              
a000c894:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
  uint32_t              old_state;                                    
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  old_state = the_thread->current_state;                              
  the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
a000c898:	e5801010 	str	r1, [r0, #16]                                 <== NOT EXECUTED
                                                                      
  if ( _States_Is_ready( old_state ) ) {                              
a000c89c:	1a000002 	bne	a000c8ac <_Thread_Set_transient+0x30>         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Extract(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.extract( the_thread );                        
a000c8a0:	e59f300c 	ldr	r3, [pc, #12]	; a000c8b4 <_Thread_Set_transient+0x38><== NOT EXECUTED
a000c8a4:	e593302c 	ldr	r3, [r3, #44]	; 0x2c                          <== NOT EXECUTED
a000c8a8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c8ac:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
    _Scheduler_Extract( the_thread );                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
a000c8b0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000c924 <_Thread_Stack_Free>: * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( Configuration.stack_free_hook )
a000c924:	e59f3024 	ldr	r3, [pc, #36]	; a000c950 <_Thread_Stack_Free+0x2c><== NOT EXECUTED
 */                                                                   
                                                                      
void _Thread_Stack_Free(                                              
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a000c928:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
   * Call ONLY the CPU table stack free hook, or the                  
   * the RTEMS workspace free.  This is so the free                   
   * routine properly matches the allocation of the stack.            
   */                                                                 
                                                                      
  if ( Configuration.stack_free_hook )                                
a000c92c:	e5933024 	ldr	r3, [r3, #36]	; 0x24                          <== NOT EXECUTED
a000c930:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c934:	0a000002 	beq	a000c944 <_Thread_Stack_Free+0x20>            <== NOT EXECUTED
    (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
a000c938:	e59000b8 	ldr	r0, [r0, #184]	; 0xb8                         <== NOT EXECUTED
a000c93c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  else                                                                
    _Workspace_Free( the_thread->Start.Initial_stack.area );          
}                                                                     
a000c940:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( Configuration.stack_free_hook )                                
    (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
  else                                                                
    _Workspace_Free( the_thread->Start.Initial_stack.area );          
a000c944:	e59000b8 	ldr	r0, [r0, #184]	; 0xb8                         <== NOT EXECUTED
}                                                                     
a000c948:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( Configuration.stack_free_hook )                                
    (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
  else                                                                
    _Workspace_Free( the_thread->Start.Initial_stack.area );          
a000c94c:	ea0001fb 	b	a000d140 <_Workspace_Free>                      <== NOT EXECUTED
                                                                      

a000c994 <_Thread_Start>: */ RTEMS_INLINE_ROUTINE bool _States_Is_dormant ( States_Control the_states ) { return (the_states & STATES_DORMANT);
a000c994:	e590c010 	ldr	ip, [r0, #16]                                 
  Thread_Start_types         the_prototype,                           
  void                      *entry_point,                             
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
a000c998:	e92d4010 	push	{r4, lr}                                     
  if ( _States_Is_dormant( the_thread->current_state ) ) {            
a000c99c:	e21cc001 	ands	ip, ip, #1                                   
  Thread_Start_types         the_prototype,                           
  void                      *entry_point,                             
  void                      *pointer_argument,                        
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
a000c9a0:	e1a04000 	mov	r4, r0                                        
  if ( _States_Is_dormant( the_thread->current_state ) ) {            
a000c9a4:	1a000001 	bne	a000c9b0 <_Thread_Start+0x1c>                 
    _User_extensions_Thread_start( the_thread );                      
                                                                      
    return true;                                                      
  }                                                                   
                                                                      
  return false;                                                       
a000c9a8:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
}                                                                     
a000c9ac:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  if ( _States_Is_dormant( the_thread->current_state ) ) {            
                                                                      
    the_thread->Start.entry_point      = (Thread_Entry) entry_point;  
                                                                      
    the_thread->Start.prototype        = the_prototype;               
    the_thread->Start.pointer_argument = pointer_argument;            
a000c9b0:	e5803098 	str	r3, [r0, #152]	; 0x98                         
    the_thread->Start.numeric_argument = numeric_argument;            
a000c9b4:	e59d3008 	ldr	r3, [sp, #8]                                  
  Thread_Entry_numeric_type  numeric_argument                         
)                                                                     
{                                                                     
  if ( _States_Is_dormant( the_thread->current_state ) ) {            
                                                                      
    the_thread->Start.entry_point      = (Thread_Entry) entry_point;  
a000c9b8:	e5802090 	str	r2, [r0, #144]	; 0x90                         
                                                                      
    the_thread->Start.prototype        = the_prototype;               
a000c9bc:	e5801094 	str	r1, [r0, #148]	; 0x94                         
    the_thread->Start.pointer_argument = pointer_argument;            
    the_thread->Start.numeric_argument = numeric_argument;            
a000c9c0:	e580309c 	str	r3, [r0, #156]	; 0x9c                         
                                                                      
    _Thread_Load_environment( the_thread );                           
a000c9c4:	eb000b4a 	bl	a000f6f4 <_Thread_Load_environment>            
                                                                      
    _Thread_Ready( the_thread );                                      
a000c9c8:	e1a00004 	mov	r0, r4                                        
a000c9cc:	eb000bee 	bl	a000f98c <_Thread_Ready>                       
                                                                      
    _User_extensions_Thread_start( the_thread );                      
a000c9d0:	e1a00004 	mov	r0, r4                                        
a000c9d4:	eb0000d4 	bl	a000cd2c <_User_extensions_Thread_start>       
                                                                      
    return true;                                                      
a000c9d8:	e3a00001 	mov	r0, #1                                        
a000c9dc:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

a000c9e0 <_Thread_Tickle_timeslice>: void _Thread_Tickle_timeslice( void ) { Thread_Control *executing; executing = _Thread_Executing;
a000c9e0:	e59f305c 	ldr	r3, [pc, #92]	; a000ca44 <_Thread_Tickle_timeslice+0x64><== NOT EXECUTED
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Thread_Tickle_timeslice( void )                                 
{                                                                     
a000c9e4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
a000c9e8:	e5934004 	ldr	r4, [r3, #4]                                  <== NOT EXECUTED
  /*                                                                  
   *  If the thread is not preemptible or is not ready, then          
   *  just return.                                                    
   */                                                                 
                                                                      
  if ( !executing->is_preemptible )                                   
a000c9ec:	e5d43074 	ldrb	r3, [r4, #116]	; 0x74                        <== NOT EXECUTED
a000c9f0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c9f4:	0a000005 	beq	a000ca10 <_Thread_Tickle_timeslice+0x30>      <== NOT EXECUTED
    return;                                                           
                                                                      
  if ( !_States_Is_ready( executing->current_state ) )                
a000c9f8:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
a000c9fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ca00:	1a000002 	bne	a000ca10 <_Thread_Tickle_timeslice+0x30>      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  The cpu budget algorithm determines what happens next.          
   */                                                                 
                                                                      
  switch ( executing->budget_algorithm ) {                            
a000ca04:	e594307c 	ldr	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a000ca08:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000ca0c:	0a000000 	beq	a000ca14 <_Thread_Tickle_timeslice+0x34>      <== NOT EXECUTED
a000ca10:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:                 
    #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)          
      case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:             
    #endif                                                            
      if ( (int)(--executing->cpu_time_budget) <= 0 ) {               
a000ca14:	e5943078 	ldr	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
a000ca18:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000ca1c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ca20:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
a000ca24:	cafffff9 	bgt	a000ca10 <_Thread_Tickle_timeslice+0x30>      <== NOT EXECUTED
 *  always operates on the scheduler that 'owns' the currently executing
 *  thread.                                                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )                    
{                                                                     
  _Scheduler.Operations.yield();                                      
a000ca28:	e59f3018 	ldr	r3, [pc, #24]	; a000ca48 <_Thread_Tickle_timeslice+0x68><== NOT EXECUTED
a000ca2c:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a000ca30:	e12fff33 	blx	r3                                            <== NOT EXECUTED
         *  executing thread's timeslice is reset.  Otherwise, the    
         *  currently executing thread is placed at the rear of the   
         *  FIFO for this priority and a new heir is selected.        
         */                                                           
        _Scheduler_Yield( );                                          
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;     
a000ca34:	e59f3010 	ldr	r3, [pc, #16]	; a000ca4c <_Thread_Tickle_timeslice+0x6c><== NOT EXECUTED
a000ca38:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000ca3c:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
a000ca40:	eafffff2 	b	a000ca10 <_Thread_Tickle_timeslice+0x30>        <== NOT EXECUTED
                                                                      

a000baf8 <_Thread_blocking_operation_Cancel>: Thread_blocking_operation_States sync_state __attribute__((unused)), #endif Thread_Control *the_thread, ISR_Level level ) {
a000baf8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the sync state is timed out, this is very likely not needed. 
   *  But better safe than sorry when it comes to critical sections.  
   */                                                                 
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {                  
a000bafc:	e5913050 	ldr	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
  Thread_blocking_operation_States  sync_state __attribute__((unused)),
#endif                                                                
  Thread_Control                   *the_thread,                       
  ISR_Level                         level                             
)                                                                     
{                                                                     
a000bb00:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the sync state is timed out, this is very likely not needed. 
   *  But better safe than sorry when it comes to critical sections.  
   */                                                                 
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {                  
a000bb04:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
  #endif                                                              
                                                                      
  /*                                                                  
   * The thread is not waiting on anything after this completes.      
   */                                                                 
  the_thread->Wait.queue = NULL;                                      
a000bb08:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000bb0c:	e5813044 	str	r3, [r1, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the sync state is timed out, this is very likely not needed. 
   *  But better safe than sorry when it comes to critical sections.  
   */                                                                 
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {                  
a000bb10:	0a000005 	beq	a000bb2c <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED
a000bb14:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a000bb18:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000bb1c:	e59f1028 	ldr	r1, [pc, #40]	; a000bb4c <_Thread_blocking_operation_Cancel+0x54><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
                                                                      
}                                                                     
a000bb20:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000bb24:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
a000bb28:	ea00004a 	b	a000bc58 <_Thread_Clear_state>                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
a000bb2c:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a000bb30:	e5813050 	str	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
a000bb34:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
   *  But better safe than sorry when it comes to critical sections.  
   */                                                                 
  if ( _Watchdog_Is_active( &the_thread->Timer ) ) {                  
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
    (void) _Watchdog_Remove( &the_thread->Timer );                    
a000bb38:	e2810048 	add	r0, r1, #72	; 0x48                            <== NOT EXECUTED
a000bb3c:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a000bb40:	eb00050b 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a000bb44:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
a000bb48:	eafffff2 	b	a000bb18 <_Thread_blocking_operation_Cancel+0x20><== NOT EXECUTED
                                                                      

a000c2cc <_Thread_queue_Dequeue>: Thread_Control *(*dequeue_p)( Thread_queue_Control * ); Thread_Control *the_thread; ISR_Level level; Thread_blocking_operation_States sync_state; if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
a000c2cc:	e5901034 	ldr	r1, [r0, #52]	; 0x34                          
    dequeue_p = _Thread_queue_Dequeue_priority;                       
a000c2d0:	e59f2054 	ldr	r2, [pc, #84]	; a000c32c <_Thread_queue_Dequeue+0x60>
 */                                                                   
                                                                      
Thread_Control *_Thread_queue_Dequeue(                                
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
a000c2d4:	e92d4010 	push	{r4, lr}                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  Thread_blocking_operation_States  sync_state;                       
                                                                      
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
    dequeue_p = _Thread_queue_Dequeue_priority;                       
a000c2d8:	e3510001 	cmp	r1, #1                                        
a000c2dc:	e59f304c 	ldr	r3, [pc, #76]	; a000c330 <_Thread_queue_Dequeue+0x64>
a000c2e0:	01a03002 	moveq	r3, r2                                      
 */                                                                   
                                                                      
Thread_Control *_Thread_queue_Dequeue(                                
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
a000c2e4:	e1a04000 	mov	r4, r0                                        
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
    dequeue_p = _Thread_queue_Dequeue_priority;                       
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */                     
    dequeue_p = _Thread_queue_Dequeue_fifo;                           
                                                                      
  the_thread = (*dequeue_p)( the_thread_queue );                      
a000c2e8:	e12fff33 	blx	r3                                            
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c2ec:	e10f3000 	mrs	r3, CPSR                                      
a000c2f0:	e3832080 	orr	r2, r3, #128	; 0x80                           
a000c2f4:	e129f002 	msr	CPSR_fc, r2                                   
  _ISR_Disable( level );                                              
    if ( !the_thread ) {                                              
a000c2f8:	e3500000 	cmp	r0, #0                                        
a000c2fc:	0a000001 	beq	a000c308 <_Thread_queue_Dequeue+0x3c>         
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c300:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        the_thread = _Thread_Executing;                               
      }                                                               
    }                                                                 
  _ISR_Enable( level );                                               
  return the_thread;                                                  
}                                                                     
a000c304:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  the_thread = (*dequeue_p)( the_thread_queue );                      
  _ISR_Disable( level );                                              
    if ( !the_thread ) {                                              
      sync_state = the_thread_queue->sync_state;                      
      if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||       
a000c308:	e5942030 	ldr	r2, [r4, #48]	; 0x30                          
a000c30c:	e2422001 	sub	r2, r2, #1                                    
a000c310:	e3520001 	cmp	r2, #1                                        
           (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
        the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
a000c314:	93a02003 	movls	r2, #3                                      
a000c318:	95842030 	strls	r2, [r4, #48]	; 0x30                        
        the_thread = _Thread_Executing;                               
a000c31c:	959f2010 	ldrls	r2, [pc, #16]	; a000c334 <_Thread_queue_Dequeue+0x68>
a000c320:	95920004 	ldrls	r0, [r2, #4]                                
a000c324:	e129f003 	msr	CPSR_fc, r3                                   
      }                                                               
    }                                                                 
  _ISR_Enable( level );                                               
  return the_thread;                                                  
}                                                                     
a000c328:	e8bd8010 	pop	{r4, pc}                                      
                                                                      

a000f744 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) {
a000f744:	e92d4030 	push	{r4, r5, lr}                                 
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000f748:	e10f2000 	mrs	r2, CPSR                                      
a000f74c:	e3823080 	orr	r3, r2, #128	; 0x80                           
a000f750:	e129f003 	msr	CPSR_fc, r3                                   
    return the_thread;                                                
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  return NULL;                                                        
}                                                                     
a000f754:	e1a03000 	mov	r3, r0                                        
a000f758:	e4934004 	ldr	r4, [r3], #4                                  
{                                                                     
  ISR_Level              level;                                       
  Thread_Control *the_thread;                                         
                                                                      
  _ISR_Disable( level );                                              
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {         
a000f75c:	e1540003 	cmp	r4, r3                                        
a000f760:	0a000018 	beq	a000f7c8 <_Thread_queue_Dequeue_fifo+0x84>    
                                                                      
    the_thread = (Thread_Control *)                                   
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
                                                                      
    the_thread->Wait.queue = NULL;                                    
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {               
a000f764:	e5941050 	ldr	r1, [r4, #80]	; 0x50                          <== NOT EXECUTED
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
a000f768:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
  Thread_Control *the_thread;                                         
                                                                      
  _ISR_Disable( level );                                              
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {         
                                                                      
    the_thread = (Thread_Control *)                                   
a000f76c:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
                                                                      
    the_thread->Wait.queue = NULL;                                    
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {               
a000f770:	e3510002 	cmp	r1, #2                                        <== NOT EXECUTED
                                                                      
  head->next = new_first;                                             
a000f774:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  new_first->previous = head;                                         
a000f778:	e5830004 	str	r0, [r3, #4]                                  <== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {         
                                                                      
    the_thread = (Thread_Control *)                                   
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
                                                                      
    the_thread->Wait.queue = NULL;                                    
a000f77c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000f780:	e5843044 	str	r3, [r4, #68]	; 0x44                          <== NOT EXECUTED
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {               
a000f784:	0a000005 	beq	a000f7a0 <_Thread_queue_Dequeue_fifo+0x5c>    <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000f788:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a000f78c:	e59f1040 	ldr	r1, [pc, #64]	; a000f7d4 <_Thread_queue_Dequeue_fifo+0x90><== NOT EXECUTED
a000f790:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f794:	ebfff12f 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
    return the_thread;                                                
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  return NULL;                                                        
}                                                                     
a000f798:	e1a00005 	mov	r0, r5                                        
a000f79c:	e8bd8030 	pop	{r4, r5, pc}                                  
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
a000f7a0:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a000f7a4:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000f7a8:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
      _ISR_Enable( level );                                           
      _Thread_Unblock( the_thread );                                  
    } else {                                                          
      _Watchdog_Deactivate( &the_thread->Timer );                     
      _ISR_Enable( level );                                           
      (void) _Watchdog_Remove( &the_thread->Timer );                  
a000f7ac:	e2840048 	add	r0, r4, #72	; 0x48                            <== NOT EXECUTED
a000f7b0:	ebfff5ef 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a000f7b4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000f7b8:	e59f1014 	ldr	r1, [pc, #20]	; a000f7d4 <_Thread_queue_Dequeue_fifo+0x90><== NOT EXECUTED
a000f7bc:	ebfff125 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
    return the_thread;                                                
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  return NULL;                                                        
}                                                                     
a000f7c0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000f7c4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
a000f7c8:	e129f002 	msr	CPSR_fc, r2                                   
                                                                      
    return the_thread;                                                
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
  return NULL;                                                        
a000f7cc:	e3a05000 	mov	r5, #0                                        
a000f7d0:	eafffff0 	b	a000f798 <_Thread_queue_Dequeue_fifo+0x54>      
                                                                      

a000c338 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) {
a000c338:	e92d4070 	push	{r4, r5, r6, lr}                             
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c33c:	e10f6000 	mrs	r6, CPSR                                      
a000c340:	e3863080 	orr	r3, r6, #128	; 0x80                           
a000c344:	e129f003 	msr	CPSR_fc, r3                                   
  Chain_Node     *new_second_node;                                    
  Chain_Node     *last_node;                                          
  Chain_Node     *next_node;                                          
  Chain_Node     *previous_node;                                      
                                                                      
  _ISR_Disable( level );                                              
a000c348:	e3a02000 	mov	r2, #0                                        
  for( index=0 ;                                                      
a000c34c:	e1a03002 	mov	r3, r2                                        
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a000c350:	e3a0c00c 	mov	ip, #12                                       
a000c354:	e001039c 	mul	r1, ip, r3                                    
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
  return( the_thread );                                               
}                                                                     
a000c358:	e7904002 	ldr	r4, [r0, r2]                                  
a000c35c:	e2811004 	add	r1, r1, #4                                    
a000c360:	e0801001 	add	r1, r0, r1                                    
                                                                      
  _ISR_Disable( level );                                              
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
a000c364:	e1540001 	cmp	r4, r1                                        
  Chain_Node     *previous_node;                                      
                                                                      
  _ISR_Disable( level );                                              
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
a000c368:	e2833001 	add	r3, r3, #1                                    
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
a000c36c:	1a000006 	bne	a000c38c <_Thread_queue_Dequeue_priority+0x54>
  Chain_Node     *last_node;                                          
  Chain_Node     *next_node;                                          
  Chain_Node     *previous_node;                                      
                                                                      
  _ISR_Disable( level );                                              
  for( index=0 ;                                                      
a000c370:	e3530004 	cmp	r3, #4                                        
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
a000c374:	e282200c 	add	r2, r2, #12                                   
  Chain_Node     *last_node;                                          
  Chain_Node     *next_node;                                          
  Chain_Node     *previous_node;                                      
                                                                      
  _ISR_Disable( level );                                              
  for( index=0 ;                                                      
a000c378:	1afffff5 	bne	a000c354 <_Thread_queue_Dequeue_priority+0x1c>
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c37c:	e129f006 	msr	CPSR_fc, r6                                   
                                                                      
  /*                                                                  
   * We did not find a thread to unblock.                             
   */                                                                 
  _ISR_Enable( level );                                               
  return NULL;                                                        
a000c380:	e3a05000 	mov	r5, #0                                        
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
  return( the_thread );                                               
}                                                                     
a000c384:	e1a00005 	mov	r0, r5                                        
a000c388:	e8bd8070 	pop	{r4, r5, r6, pc}                              
a000c38c:	e5943038 	ldr	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
a000c390:	e284203c 	add	r2, r4, #60	; 0x3c                            <== NOT EXECUTED
  _ISR_Disable( level );                                              
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
      the_thread = (Thread_Control *) _Chain_First(                   
a000c394:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
  new_first_node   = _Chain_First( &the_thread->Wait.Block2n );       
  new_first_thread = (Thread_Control *) new_first_node;               
  next_node        = the_thread->Object.Node.next;                    
  previous_node    = the_thread->Object.Node.previous;                
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
a000c398:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
   */                                                                 
  _ISR_Enable( level );                                               
  return NULL;                                                        
                                                                      
dequeue:                                                              
  the_thread->Wait.queue = NULL;                                      
a000c39c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000c3a0:	e5842044 	str	r2, [r4, #68]	; 0x44                          <== NOT EXECUTED
  new_first_node   = _Chain_First( &the_thread->Wait.Block2n );       
  new_first_thread = (Thread_Control *) new_first_node;               
  next_node        = the_thread->Object.Node.next;                    
  previous_node    = the_thread->Object.Node.previous;                
a000c3a4:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
                                                                      
dequeue:                                                              
  the_thread->Wait.queue = NULL;                                      
  new_first_node   = _Chain_First( &the_thread->Wait.Block2n );       
  new_first_thread = (Thread_Control *) new_first_node;               
  next_node        = the_thread->Object.Node.next;                    
a000c3a8:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
  previous_node    = the_thread->Object.Node.previous;                
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
a000c3ac:	0a000020 	beq	a000c434 <_Thread_queue_Dequeue_priority+0xfc><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
  return( the_thread );                                               
}                                                                     
a000c3b0:	e5940040 	ldr	r0, [r4, #64]	; 0x40                          <== NOT EXECUTED
  next_node        = the_thread->Object.Node.next;                    
  previous_node    = the_thread->Object.Node.previous;                
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
    last_node       = _Chain_Last( &the_thread->Wait.Block2n );       
    new_second_node = new_first_node->next;                           
a000c3b4:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
                                                                      
    previous_node->next      = new_first_node;                        
    next_node->previous      = new_first_node;                        
a000c3b8:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
    last_node       = _Chain_Last( &the_thread->Wait.Block2n );       
    new_second_node = new_first_node->next;                           
                                                                      
    previous_node->next      = new_first_node;                        
a000c3bc:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
    next_node->previous      = new_first_node;                        
    new_first_node->next     = next_node;                             
    new_first_node->previous = previous_node;                         
a000c3c0:	e5831004 	str	r1, [r3, #4]                                  <== NOT EXECUTED
    last_node       = _Chain_Last( &the_thread->Wait.Block2n );       
    new_second_node = new_first_node->next;                           
                                                                      
    previous_node->next      = new_first_node;                        
    next_node->previous      = new_first_node;                        
    new_first_node->next     = next_node;                             
a000c3c4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    new_first_node->previous = previous_node;                         
                                                                      
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {   
a000c3c8:	e5941038 	ldr	r1, [r4, #56]	; 0x38                          <== NOT EXECUTED
a000c3cc:	e5942040 	ldr	r2, [r4, #64]	; 0x40                          <== NOT EXECUTED
a000c3d0:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a000c3d4:	0a000005 	beq	a000c3f0 <_Thread_queue_Dequeue_priority+0xb8><== NOT EXECUTED
                                                /* > two threads on 2-n */
      head = _Chain_Head( &new_first_thread->Wait.Block2n );          
a000c3d8:	e2831038 	add	r1, r3, #56	; 0x38                            <== NOT EXECUTED
      tail = _Chain_Tail( &new_first_thread->Wait.Block2n );          
a000c3dc:	e283203c 	add	r2, r3, #60	; 0x3c                            <== NOT EXECUTED
                                                                      
      new_second_node->previous = head;                               
a000c3e0:	e58c1004 	str	r1, [ip, #4]                                  <== NOT EXECUTED
      head->next = new_second_node;                                   
a000c3e4:	e583c038 	str	ip, [r3, #56]	; 0x38                          <== NOT EXECUTED
      tail->previous = last_node;                                     
a000c3e8:	e5830040 	str	r0, [r3, #64]	; 0x40                          <== NOT EXECUTED
      last_node->next = tail;                                         
a000c3ec:	e5802000 	str	r2, [r0]                                      <== NOT EXECUTED
  } else {                                                            
    previous_node->next = next_node;                                  
    next_node->previous = previous_node;                              
  }                                                                   
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
a000c3f0:	e5943050 	ldr	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000c3f4:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a000c3f8:	0a000004 	beq	a000c410 <_Thread_queue_Dequeue_priority+0xd8><== NOT EXECUTED
a000c3fc:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a000c400:	e59f1038 	ldr	r1, [pc, #56]	; a000c440 <_Thread_queue_Dequeue_priority+0x108><== NOT EXECUTED
a000c404:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000c408:	ebfffe12 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
a000c40c:	eaffffdc 	b	a000c384 <_Thread_queue_Dequeue_priority+0x4c>  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
a000c410:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a000c414:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
a000c418:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
    _Thread_Unblock( the_thread );                                    
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
    (void) _Watchdog_Remove( &the_thread->Timer );                    
a000c41c:	e2840048 	add	r0, r4, #72	; 0x48                            <== NOT EXECUTED
a000c420:	eb0002d3 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a000c424:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000c428:	e59f1010 	ldr	r1, [pc, #16]	; a000c440 <_Thread_queue_Dequeue_priority+0x108><== NOT EXECUTED
a000c42c:	ebfffe09 	bl	a000bc58 <_Thread_Clear_state>                 <== NOT EXECUTED
a000c430:	eaffffd3 	b	a000c384 <_Thread_queue_Dequeue_priority+0x4c>  <== NOT EXECUTED
      head->next = new_second_node;                                   
      tail->previous = last_node;                                     
      last_node->next = tail;                                         
    }                                                                 
  } else {                                                            
    previous_node->next = next_node;                                  
a000c434:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
    next_node->previous = previous_node;                              
a000c438:	e5821004 	str	r1, [r2, #4]                                  <== NOT EXECUTED
a000c43c:	eaffffeb 	b	a000c3f0 <_Thread_queue_Dequeue_priority+0xb8>  <== NOT EXECUTED
                                                                      

a000f7d8 <_Thread_queue_Enqueue_fifo>: Thread_blocking_operation_States _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) {
a000f7d8:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
a000f7dc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000f7e0:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000f7e4:	e3840080 	orr	r0, r4, #128	; 0x80                           <== NOT EXECUTED
a000f7e8:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
  Thread_blocking_operation_States sync_state;                        
  ISR_Level                        level;                             
                                                                      
  _ISR_Disable( level );                                              
                                                                      
    sync_state = the_thread_queue->sync_state;                        
a000f7ec:	e5930030 	ldr	r0, [r3, #48]	; 0x30                          <== NOT EXECUTED
    the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a000f7f0:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a000f7f4:	e583c030 	str	ip, [r3, #48]	; 0x30                          <== NOT EXECUTED
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {   
a000f7f8:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
   *  For example, the blocking thread could have been given          
   *  the mutex by an ISR or timed out.                               
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
a000f7fc:	15824000 	strne	r4, [r2]                                    <== NOT EXECUTED
                                                                      
  _ISR_Disable( level );                                              
                                                                      
    sync_state = the_thread_queue->sync_state;                        
    the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {   
a000f800:	0a000001 	beq	a000f80c <_Thread_queue_Enqueue_fifo+0x34>    <== NOT EXECUTED
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
  return sync_state;                                                  
}                                                                     
a000f804:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a000f808:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a000f80c:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000f810:	e283c004 	add	ip, r3, #4                                    <== NOT EXECUTED
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a000f814:	e5831008 	str	r1, [r3, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a000f818:	e581c000 	str	ip, [r1]                                      <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
a000f81c:	e5812004 	str	r2, [r1, #4]                                  <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a000f820:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {   
      _Chain_Append_unprotected(                                      
        &the_thread_queue->Queues.Fifo,                               
        &the_thread->Object.Node                                      
      );                                                              
      the_thread->Wait.queue = the_thread_queue;                      
a000f824:	e5813044 	str	r3, [r1, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000f828:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
                                                                      
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
      _ISR_Enable( level );                                           
      return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;              
a000f82c:	eafffff4 	b	a000f804 <_Thread_queue_Enqueue_fifo+0x2c>      <== NOT EXECUTED
                                                                      

a000c4f0 <_Thread_queue_Enqueue_priority>: Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority;
a000c4f0:	e5913014 	ldr	r3, [r1, #20]                                 <== NOT EXECUTED
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (     
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread,                                   
  ISR_Level            *level_p                                       
)                                                                     
{                                                                     
a000c4f4:	e92d05f0 	push	{r4, r5, r6, r7, r8, sl}                     <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
a000c4f8:	e281403c 	add	r4, r1, #60	; 0x3c                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(                    
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
a000c4fc:	e281c038 	add	ip, r1, #56	; 0x38                            <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a000c500:	e5814038 	str	r4, [r1, #56]	; 0x38                          <== NOT EXECUTED
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
  block_state  = the_thread_queue->state;                             
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
a000c504:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
  head->previous = NULL;                                              
a000c508:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
  tail->previous = head;                                              
a000c50c:	e581c040 	str	ip, [r1, #64]	; 0x40                          <== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
a000c510:	e581403c 	str	r4, [r1, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE uint32_t   _Thread_queue_Header_number (         
  Priority_Control the_priority                                       
)                                                                     
{                                                                     
  return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);      
a000c514:	e1a0c323 	lsr	ip, r3, #6                                    <== NOT EXECUTED
  _Chain_Initialize_empty( &the_thread->Wait.Block2n );               
                                                                      
  priority     = the_thread->current_priority;                        
  header_index = _Thread_queue_Header_number( priority );             
  header       = &the_thread_queue->Queues.Priority[ header_index ];  
  block_state  = the_thread_queue->state;                             
a000c518:	e5905038 	ldr	r5, [r0, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
a000c51c:	0a00001e 	beq	a000c59c <_Thread_queue_Enqueue_priority+0xac><== NOT EXECUTED
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
  return the_thread_queue->sync_state;                                
}                                                                     
a000c520:	e3a0700c 	mov	r7, #12                                       <== NOT EXECUTED
a000c524:	e59fa174 	ldr	sl, [pc, #372]	; a000c6a0 <_Thread_queue_Enqueue_priority+0x1b0><== NOT EXECUTED
a000c528:	e027079c 	mla	r7, ip, r7, r0                                <== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
a000c52c:	e5da4000 	ldrb	r4, [sl]                                     <== NOT EXECUTED
a000c530:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c534:	e10f8000 	mrs	r8, CPSR                                      <== NOT EXECUTED
a000c538:	e388c080 	orr	ip, r8, #128	; 0x80                           <== NOT EXECUTED
a000c53c:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
  return the_thread_queue->sync_state;                                
}                                                                     
a000c540:	e597c008 	ldr	ip, [r7, #8]                                  <== NOT EXECUTED
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) _Chain_Last( header );           
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
a000c544:	e15c0007 	cmp	ip, r7                                        <== NOT EXECUTED
a000c548:	1a000009 	bne	a000c574 <_Thread_queue_Enqueue_priority+0x84><== NOT EXECUTED
a000c54c:	ea00000b 	b	a000c580 <_Thread_queue_Enqueue_priority+0x90>  <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000c550:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a000c554:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
a000c558:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _States_Are_set (                           
  States_Control the_states,                                          
  States_Control mask                                                 
)                                                                     
{                                                                     
   return ( (the_states & mask) != STATES_READY);                     
a000c55c:	e59c6010 	ldr	r6, [ip, #16]                                 <== NOT EXECUTED
    search_priority = search_thread->current_priority;                
    if ( priority >= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a000c560:	e1150006 	tst	r5, r6                                        <== NOT EXECUTED
a000c564:	0a000033 	beq	a000c638 <_Thread_queue_Enqueue_priority+0x148><== NOT EXECUTED
      _ISR_Enable( level );                                           
      goto restart_reverse_search;                                    
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
a000c568:	e59cc004 	ldr	ip, [ip, #4]                                  <== NOT EXECUTED
restart_reverse_search:                                               
  search_priority     = PRIORITY_MAXIMUM + 1;                         
                                                                      
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) _Chain_Last( header );           
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {  
a000c56c:	e15c0007 	cmp	ip, r7                                        <== NOT EXECUTED
a000c570:	0a000002 	beq	a000c580 <_Thread_queue_Enqueue_priority+0x90><== NOT EXECUTED
    search_priority = search_thread->current_priority;                
a000c574:	e59c4014 	ldr	r4, [ip, #20]                                 <== NOT EXECUTED
    if ( priority >= search_priority )                                
a000c578:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000c57c:	3afffff3 	bcc	a000c550 <_Thread_queue_Enqueue_priority+0x60><== NOT EXECUTED
    }                                                                 
    search_thread = (Thread_Control *)                                
                         search_thread->Object.Node.previous;         
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
a000c580:	e5905030 	ldr	r5, [r0, #48]	; 0x30                          <== NOT EXECUTED
a000c584:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
a000c588:	0a00002e 	beq	a000c648 <_Thread_queue_Enqueue_priority+0x158><== NOT EXECUTED
   *  For example, the blocking thread could have been given          
   *  the mutex by an ISR or timed out.                               
   *                                                                  
   *  WARNING! Returning with interrupts disabled!                    
   */                                                                 
  *level_p = level;                                                   
a000c58c:	e5828000 	str	r8, [r2]                                      <== NOT EXECUTED
  return the_thread_queue->sync_state;                                
}                                                                     
a000c590:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000c594:	e8bd05f0 	pop	{r4, r5, r6, r7, r8, sl}                      <== NOT EXECUTED
a000c598:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
a000c59c:	e3a0400c 	mov	r4, #12                                       <== NOT EXECUTED
a000c5a0:	e00c0c94 	mul	ip, r4, ip                                    <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  Chain_Control *the_chain,                                           
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Tail(the_chain));                        
a000c5a4:	e28c7004 	add	r7, ip, #4                                    <== NOT EXECUTED
a000c5a8:	e080a00c 	add	sl, r0, ip                                    <== NOT EXECUTED
a000c5ac:	e0807007 	add	r7, r0, r7                                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c5b0:	e10f8000 	mrs	r8, CPSR                                      <== NOT EXECUTED
a000c5b4:	e388c080 	orr	ip, r8, #128	; 0x80                           <== NOT EXECUTED
a000c5b8:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a000c5bc:	e59ac000 	ldr	ip, [sl]                                      <== NOT EXECUTED
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) _Chain_First( header );          
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
a000c5c0:	e15c0007 	cmp	ip, r7                                        <== NOT EXECUTED
a000c5c4:	1a000009 	bne	a000c5f0 <_Thread_queue_Enqueue_priority+0x100><== NOT EXECUTED
a000c5c8:	ea000032 	b	a000c698 <_Thread_queue_Enqueue_priority+0x1a8> <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000c5cc:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a000c5d0:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
a000c5d4:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
a000c5d8:	e59c6010 	ldr	r6, [ip, #16]                                 <== NOT EXECUTED
    search_priority = search_thread->current_priority;                
    if ( priority <= search_priority )                                
      break;                                                          
#endif                                                                
    _ISR_Flash( level );                                              
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a000c5dc:	e1150006 	tst	r5, r6                                        <== NOT EXECUTED
a000c5e0:	0a000016 	beq	a000c640 <_Thread_queue_Enqueue_priority+0x150><== NOT EXECUTED
      _ISR_Enable( level );                                           
      goto restart_forward_search;                                    
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
a000c5e4:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
  _ISR_Disable( level );                                              
  search_thread = (Thread_Control *) _Chain_First( header );          
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {  
a000c5e8:	e15c0007 	cmp	ip, r7                                        <== NOT EXECUTED
a000c5ec:	0a000002 	beq	a000c5fc <_Thread_queue_Enqueue_priority+0x10c><== NOT EXECUTED
    search_priority = search_thread->current_priority;                
a000c5f0:	e59c4014 	ldr	r4, [ip, #20]                                 <== NOT EXECUTED
    if ( priority <= search_priority )                                
a000c5f4:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000c5f8:	8afffff3 	bhi	a000c5cc <_Thread_queue_Enqueue_priority+0xdc><== NOT EXECUTED
    }                                                                 
    search_thread =                                                   
       (Thread_Control *)search_thread->Object.Node.next;             
  }                                                                   
                                                                      
  if ( the_thread_queue->sync_state !=                                
a000c5fc:	e5905030 	ldr	r5, [r0, #48]	; 0x30                          <== NOT EXECUTED
a000c600:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
a000c604:	1affffe0 	bne	a000c58c <_Thread_queue_Enqueue_priority+0x9c><== NOT EXECUTED
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
a000c608:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a000c60c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000c610:	e5803030 	str	r3, [r0, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
  if ( priority == search_priority )                                  
a000c614:	0a000016 	beq	a000c674 <_Thread_queue_Enqueue_priority+0x184><== NOT EXECUTED
    goto equal_priority;                                              
                                                                      
  search_node   = (Chain_Node *) search_thread;                       
  previous_node = search_node->previous;                              
a000c618:	e59c3004 	ldr	r3, [ip, #4]                                  <== NOT EXECUTED
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
a000c61c:	e581c000 	str	ip, [r1]                                      <== NOT EXECUTED
  the_node->previous     = previous_node;                             
a000c620:	e5813004 	str	r3, [r1, #4]                                  <== NOT EXECUTED
  previous_node->next    = the_node;                                  
a000c624:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
  search_node->previous  = the_node;                                  
a000c628:	e58c1004 	str	r1, [ip, #4]                                  <== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;                          
a000c62c:	e5810044 	str	r0, [r1, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c630:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
a000c634:	eaffffd5 	b	a000c590 <_Thread_queue_Enqueue_priority+0xa0>  <== NOT EXECUTED
a000c638:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
a000c63c:	eaffffba 	b	a000c52c <_Thread_queue_Enqueue_priority+0x3c>  <== NOT EXECUTED
a000c640:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
a000c644:	eaffffd9 	b	a000c5b0 <_Thread_queue_Enqueue_priority+0xc0>  <== NOT EXECUTED
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
                                                                      
  if ( priority == search_priority )                                  
a000c648:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
                                                                      
  if ( the_thread_queue->sync_state !=                                
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )                   
    goto synchronize;                                                 
                                                                      
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a000c64c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000c650:	e5803030 	str	r3, [r0, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
  if ( priority == search_priority )                                  
a000c654:	0a000006 	beq	a000c674 <_Thread_queue_Enqueue_priority+0x184><== NOT EXECUTED
    goto equal_priority;                                              
                                                                      
  search_node = (Chain_Node *) search_thread;                         
  next_node   = search_node->next;                                    
a000c658:	e59c3000 	ldr	r3, [ip]                                      <== NOT EXECUTED
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
a000c65c:	e8811008 	stm	r1, {r3, ip}                                  <== NOT EXECUTED
  search_node->next       = the_node;                                 
  next_node->previous    = the_node;                                  
a000c660:	e5831004 	str	r1, [r3, #4]                                  <== NOT EXECUTED
  next_node   = search_node->next;                                    
  the_node    = (Chain_Node *) the_thread;                            
                                                                      
  the_node->next          = next_node;                                
  the_node->previous      = search_node;                              
  search_node->next       = the_node;                                 
a000c664:	e58c1000 	str	r1, [ip]                                      <== NOT EXECUTED
  next_node->previous    = the_node;                                  
  the_thread->Wait.queue = the_thread_queue;                          
a000c668:	e5810044 	str	r0, [r1, #68]	; 0x44                          <== NOT EXECUTED
a000c66c:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
a000c670:	eaffffc6 	b	a000c590 <_Thread_queue_Enqueue_priority+0xa0>  <== NOT EXECUTED
                                                                      
equal_priority:               /* add at end of priority group */      
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );        
  previous_node = search_node->previous;                              
a000c674:	e59c3040 	ldr	r3, [ip, #64]	; 0x40                          <== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;                          
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
                                                                      
equal_priority:               /* add at end of priority group */      
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );        
a000c678:	e28c203c 	add	r2, ip, #60	; 0x3c                            <== NOT EXECUTED
  previous_node = search_node->previous;                              
  the_node      = (Chain_Node *) the_thread;                          
                                                                      
  the_node->next         = search_node;                               
a000c67c:	e881000c 	stm	r1, {r2, r3}                                  <== NOT EXECUTED
  the_node->previous     = previous_node;                             
  previous_node->next    = the_node;                                  
a000c680:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
  search_node->previous  = the_node;                                  
a000c684:	e58c1040 	str	r1, [ip, #64]	; 0x40                          <== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;                          
a000c688:	e5810044 	str	r0, [r1, #68]	; 0x44                          <== NOT EXECUTED
a000c68c:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;                  
a000c690:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
a000c694:	eaffffbd 	b	a000c590 <_Thread_queue_Enqueue_priority+0xa0>  <== NOT EXECUTED
                                                                      
  if ( _Thread_queue_Is_reverse_search( priority ) )                  
    goto restart_reverse_search;                                      
                                                                      
restart_forward_search:                                               
  search_priority = PRIORITY_MINIMUM - 1;                             
a000c698:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a000c69c:	eaffffd6 	b	a000c5fc <_Thread_queue_Enqueue_priority+0x10c> <== NOT EXECUTED
                                                                      

a000c444 <_Thread_queue_Enqueue_with_handler>: Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing;
a000c444:	e59f3094 	ldr	r3, [pc, #148]	; a000c4e0 <_Thread_queue_Enqueue_with_handler+0x9c><== NOT EXECUTED
void _Thread_queue_Enqueue_with_handler(                              
  Thread_queue_Control         *the_thread_queue,                     
  Watchdog_Interval             timeout,                              
  Thread_queue_Timeout_callout  handler                               
)                                                                     
{                                                                     
a000c448:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    Thread_queue_Control *,                                           
    Thread_Control *,                                                 
    ISR_Level *                                                       
  );                                                                  
                                                                      
  the_thread = _Thread_Executing;                                     
a000c44c:	e5934004 	ldr	r4, [r3, #4]                                  <== NOT EXECUTED
void _Thread_queue_Enqueue_with_handler(                              
  Thread_queue_Control         *the_thread_queue,                     
  Watchdog_Interval             timeout,                              
  Thread_queue_Timeout_callout  handler                               
)                                                                     
{                                                                     
a000c450:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a000c454:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  else                                                                
#endif                                                                
  /*                                                                  
   *  Set the blocking state for this thread queue in the thread.     
   */                                                                 
  _Thread_Set_state( the_thread, the_thread_queue->state );           
a000c458:	e5901038 	ldr	r1, [r0, #56]	; 0x38                          <== NOT EXECUTED
void _Thread_queue_Enqueue_with_handler(                              
  Thread_queue_Control         *the_thread_queue,                     
  Watchdog_Interval             timeout,                              
  Thread_queue_Timeout_callout  handler                               
)                                                                     
{                                                                     
a000c45c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  else                                                                
#endif                                                                
  /*                                                                  
   *  Set the blocking state for this thread queue in the thread.     
   */                                                                 
  _Thread_Set_state( the_thread, the_thread_queue->state );           
a000c460:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
void _Thread_queue_Enqueue_with_handler(                              
  Thread_queue_Control         *the_thread_queue,                     
  Watchdog_Interval             timeout,                              
  Thread_queue_Timeout_callout  handler                               
)                                                                     
{                                                                     
a000c464:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
  else                                                                
#endif                                                                
  /*                                                                  
   *  Set the blocking state for this thread queue in the thread.     
   */                                                                 
  _Thread_Set_state( the_thread, the_thread_queue->state );           
a000c468:	eb0000f1 	bl	a000c834 <_Thread_Set_state>                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the thread wants to timeout, then schedule its timer.        
   */                                                                 
  if ( timeout ) {                                                    
a000c46c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000c470:	1a00000f 	bne	a000c4b4 <_Thread_queue_Enqueue_with_handler+0x70><== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now enqueue the thread per the discipline for this thread queue.
   */                                                                 
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
a000c474:	e595c034 	ldr	ip, [r5, #52]	; 0x34                          <== NOT EXECUTED
    enqueue_p = _Thread_queue_Enqueue_priority;                       
a000c478:	e59f2064 	ldr	r2, [pc, #100]	; a000c4e4 <_Thread_queue_Enqueue_with_handler+0xa0><== NOT EXECUTED
a000c47c:	e59f3064 	ldr	r3, [pc, #100]	; a000c4e8 <_Thread_queue_Enqueue_with_handler+0xa4><== NOT EXECUTED
a000c480:	e35c0001 	cmp	ip, #1                                        <== NOT EXECUTED
a000c484:	01a03002 	moveq	r3, r2                                      <== NOT EXECUTED
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */                     
    enqueue_p = _Thread_queue_Enqueue_fifo;                           
                                                                      
  sync_state = (*enqueue_p)( the_thread_queue, the_thread, &level );  
a000c488:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000c48c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000c490:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000c494:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )     
a000c498:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000c49c:	0a000002 	beq	a000c4ac <_Thread_queue_Enqueue_with_handler+0x68><== NOT EXECUTED
    _Thread_blocking_operation_Cancel( sync_state, the_thread, level );
a000c4a0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000c4a4:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a000c4a8:	ebfffd92 	bl	a000baf8 <_Thread_blocking_operation_Cancel>   <== NOT EXECUTED
}                                                                     
a000c4ac:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000c4b0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If the thread wants to timeout, then schedule its timer.        
   */                                                                 
  if ( timeout ) {                                                    
    _Watchdog_Initialize(                                             
a000c4b4:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000c4b8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000c4bc:	e5843050 	str	r3, [r4, #80]	; 0x50                          <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a000c4c0:	e5847064 	str	r7, [r4, #100]	; 0x64                         <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a000c4c4:	e5842068 	str	r2, [r4, #104]	; 0x68                         <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a000c4c8:	e584306c 	str	r3, [r4, #108]	; 0x6c                         <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000c4cc:	e5846054 	str	r6, [r4, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000c4d0:	e59f0014 	ldr	r0, [pc, #20]	; a000c4ec <_Thread_queue_Enqueue_with_handler+0xa8><== NOT EXECUTED
a000c4d4:	e2841048 	add	r1, r4, #72	; 0x48                            <== NOT EXECUTED
a000c4d8:	eb000236 	bl	a000cdb8 <_Watchdog_Insert>                    <== NOT EXECUTED
a000c4dc:	eaffffe4 	b	a000c474 <_Thread_queue_Enqueue_with_handler+0x30><== NOT EXECUTED
                                                                      

a000f830 <_Thread_queue_Extract>: { /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
a000f830:	e5903034 	ldr	r3, [r0, #52]	; 0x34                          <== NOT EXECUTED
a000f834:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000f838:	0a000000 	beq	a000f840 <_Thread_queue_Extract+0x10>         <== NOT EXECUTED
    _Thread_queue_Extract_priority( the_thread_queue, the_thread );   
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */                     
    _Thread_queue_Extract_fifo( the_thread_queue, the_thread );       
a000f83c:	ea0005ef 	b	a0011000 <_Thread_queue_Extract_fifo>           <== NOT EXECUTED
  /*                                                                  
   * Can not use indirect function pointer here since Extract priority
   * is a macro and the underlying methods do not have the same signature.
   */                                                                 
  if  ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
    _Thread_queue_Extract_priority( the_thread_queue, the_thread );   
a000f840:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000f844:	eaffffff 	b	a000f848 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
                                                                      

a0011000 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) {
a0011000:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0011004:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0011008:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a001100c:	e3803080 	orr	r3, r0, #128	; 0x80                           <== NOT EXECUTED
a0011010:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
a0011014:	e5912010 	ldr	r2, [r1, #16]                                 <== NOT EXECUTED
a0011018:	e3a03bef 	mov	r3, #244736	; 0x3bc00                         <== NOT EXECUTED
a001101c:	e2833e2e 	add	r3, r3, #736	; 0x2e0                          <== NOT EXECUTED
a0011020:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
a0011024:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0011028:	0a00000d 	beq	a0011064 <_Thread_queue_Extract_fifo+0x64>    <== NOT EXECUTED
                                                                      
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
                                                                      
  the_thread->Wait.queue = NULL;                                      
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
a001102c:	e591c050 	ldr	ip, [r1, #80]	; 0x50                          <== NOT EXECUTED
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
a0011030:	e891000c 	ldm	r1, {r2, r3}                                  <== NOT EXECUTED
a0011034:	e35c0002 	cmp	ip, #2                                        <== NOT EXECUTED
  next->previous = previous;                                          
a0011038:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a001103c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  _Chain_Extract_unprotected( &the_thread->Object.Node );             
                                                                      
  the_thread->Wait.queue = NULL;                                      
a0011040:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0011044:	e5813044 	str	r3, [r1, #68]	; 0x44                          <== NOT EXECUTED
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
a0011048:	0a000008 	beq	a0011070 <_Thread_queue_Extract_fifo+0x70>    <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001104c:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
a0011050:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0011054:	e59f1034 	ldr	r1, [pc, #52]	; a0011090 <_Thread_queue_Extract_fifo+0x90><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
                                                                      
}                                                                     
a0011058:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001105c:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
a0011060:	eaffeafc 	b	a000bc58 <_Thread_Clear_state>                  <== NOT EXECUTED
a0011064:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a0011068:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001106c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
a0011070:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a0011074:	e5813050 	str	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
a0011078:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
    _ISR_Enable( level );                                             
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
    (void) _Watchdog_Remove( &the_thread->Timer );                    
a001107c:	e2810048 	add	r0, r1, #72	; 0x48                            <== NOT EXECUTED
a0011080:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a0011084:	ebffefba 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a0011088:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
a001108c:	eaffffef 	b	a0011050 <_Thread_queue_Extract_fifo+0x50>      <== NOT EXECUTED
                                                                      

a000f848 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread, bool requeuing ) {
a000f848:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a000f84c:	e20220ff 	and	r2, r2, #255	; 0xff                           <== NOT EXECUTED
a000f850:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000f854:	e10fc000 	mrs	ip, CPSR                                      <== NOT EXECUTED
a000f858:	e38c3080 	orr	r3, ip, #128	; 0x80                           <== NOT EXECUTED
a000f85c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_WAITING_ON_THREAD_QUEUE);              
a000f860:	e5910010 	ldr	r0, [r1, #16]                                 <== NOT EXECUTED
a000f864:	e3a03bef 	mov	r3, #244736	; 0x3bc00                         <== NOT EXECUTED
a000f868:	e2833e2e 	add	r3, r3, #736	; 0x2e0                          <== NOT EXECUTED
a000f86c:	e0003003 	and	r3, r0, r3                                    <== NOT EXECUTED
  Chain_Node     *new_second_node;                                    
  Chain_Node     *last_node;                                          
                                                                      
  the_node = (Chain_Node *) the_thread;                               
  _ISR_Disable( level );                                              
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
a000f870:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000f874:	0a000024 	beq	a000f90c <_Thread_queue_Extract_priority_helper+0xc4><== NOT EXECUTED
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
}                                                                     
a000f878:	e5913038 	ldr	r3, [r1, #56]	; 0x38                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a000f87c:	e281403c 	add	r4, r1, #60	; 0x3c                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  The thread was actually waiting on a thread queue so let's remove it.
   */                                                                 
                                                                      
  next_node     = the_node->next;                                     
a000f880:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
  previous_node = the_node->previous;                                 
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
a000f884:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
  /*                                                                  
   *  The thread was actually waiting on a thread queue so let's remove it.
   */                                                                 
                                                                      
  next_node     = the_node->next;                                     
  previous_node = the_node->previous;                                 
a000f888:	e5914004 	ldr	r4, [r1, #4]                                  <== NOT EXECUTED
      head->next = new_second_node;                                   
      tail->previous = last_node;                                     
      last_node->next = tail;                                         
    }                                                                 
  } else {                                                            
    previous_node->next = next_node;                                  
a000f88c:	05840000 	streq	r0, [r4]                                    <== NOT EXECUTED
    next_node->previous = previous_node;                              
a000f890:	05804004 	streq	r4, [r0, #4]                                <== NOT EXECUTED
   */                                                                 
                                                                      
  next_node     = the_node->next;                                     
  previous_node = the_node->previous;                                 
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
a000f894:	0a00000e 	beq	a000f8d4 <_Thread_queue_Extract_priority_helper+0x8c><== NOT EXECUTED
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
}                                                                     
a000f898:	e5915040 	ldr	r5, [r1, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {              
    new_first_node   = _Chain_First( &the_thread->Wait.Block2n );     
    new_first_thread = (Thread_Control *) new_first_node;             
    last_node        = _Chain_Last( &the_thread->Wait.Block2n );      
    new_second_node  = new_first_node->next;                          
a000f89c:	e5936000 	ldr	r6, [r3]                                      <== NOT EXECUTED
                                                                      
    previous_node->next      = new_first_node;                        
    next_node->previous      = new_first_node;                        
a000f8a0:	e5803004 	str	r3, [r0, #4]                                  <== NOT EXECUTED
    new_first_node   = _Chain_First( &the_thread->Wait.Block2n );     
    new_first_thread = (Thread_Control *) new_first_node;             
    last_node        = _Chain_Last( &the_thread->Wait.Block2n );      
    new_second_node  = new_first_node->next;                          
                                                                      
    previous_node->next      = new_first_node;                        
a000f8a4:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    next_node->previous      = new_first_node;                        
    new_first_node->next     = next_node;                             
    new_first_node->previous = previous_node;                         
a000f8a8:	e8830011 	stm	r3, {r0, r4}                                  <== NOT EXECUTED
                                                                      
    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {   
a000f8ac:	e5914038 	ldr	r4, [r1, #56]	; 0x38                          <== NOT EXECUTED
a000f8b0:	e5910040 	ldr	r0, [r1, #64]	; 0x40                          <== NOT EXECUTED
a000f8b4:	e1540000 	cmp	r4, r0                                        <== NOT EXECUTED
a000f8b8:	0a000005 	beq	a000f8d4 <_Thread_queue_Extract_priority_helper+0x8c><== NOT EXECUTED
                                        /* > two threads on 2-n */    
      head = _Chain_Head( &new_first_thread->Wait.Block2n );          
a000f8bc:	e2834038 	add	r4, r3, #56	; 0x38                            <== NOT EXECUTED
      tail = _Chain_Tail( &new_first_thread->Wait.Block2n );          
a000f8c0:	e283003c 	add	r0, r3, #60	; 0x3c                            <== NOT EXECUTED
                                                                      
      new_second_node->previous = head;                               
a000f8c4:	e5864004 	str	r4, [r6, #4]                                  <== NOT EXECUTED
      head->next = new_second_node;                                   
a000f8c8:	e5836038 	str	r6, [r3, #56]	; 0x38                          <== NOT EXECUTED
      tail->previous = last_node;                                     
a000f8cc:	e5835040 	str	r5, [r3, #64]	; 0x40                          <== NOT EXECUTED
      last_node->next = tail;                                         
a000f8d0:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If we are not supposed to touch timers or the thread's state, return.
   */                                                                 
                                                                      
  if ( requeuing ) {                                                  
a000f8d4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000f8d8:	1a000008 	bne	a000f900 <_Thread_queue_Extract_priority_helper+0xb8><== NOT EXECUTED
    _ISR_Enable( level );                                             
    return;                                                           
  }                                                                   
                                                                      
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
a000f8dc:	e5913050 	ldr	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
a000f8e0:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a000f8e4:	0a00000a 	beq	a000f914 <_Thread_queue_Extract_priority_helper+0xcc><== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000f8e8:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a000f8ec:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000f8f0:	e59f103c 	ldr	r1, [pc, #60]	; a000f934 <_Thread_queue_Extract_priority_helper+0xec><== NOT EXECUTED
                                                                      
#if defined(RTEMS_MULTIPROCESSING)                                    
  if ( !_Objects_Is_local_id( the_thread->Object.id ) )               
    _Thread_MP_Free_proxy( the_thread );                              
#endif                                                                
}                                                                     
a000f8f4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000f8f8:	e8bd4070 	pop	{r4, r5, r6, lr}                              <== NOT EXECUTED
a000f8fc:	eafff0d5 	b	a000bc58 <_Thread_Clear_state>                  <== NOT EXECUTED
a000f900:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a000f904:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000f908:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
a000f90c:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
a000f910:	eafffffb 	b	a000f904 <_Thread_queue_Extract_priority_helper+0xbc><== NOT EXECUTED
a000f914:	e3a03003 	mov	r3, #3                                        <== NOT EXECUTED
a000f918:	e5813050 	str	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
a000f91c:	e129f00c 	msr	CPSR_fc, ip                                   <== NOT EXECUTED
  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {                 
    _ISR_Enable( level );                                             
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
    (void) _Watchdog_Remove( &the_thread->Timer );                    
a000f920:	e2810048 	add	r0, r1, #72	; 0x48                            <== NOT EXECUTED
a000f924:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a000f928:	ebfff591 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
a000f92c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
a000f930:	eaffffed 	b	a000f8ec <_Thread_queue_Extract_priority_helper+0xa4><== NOT EXECUTED
                                                                      

a000c6a4 <_Thread_queue_Extract_with_proxy>: */ RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue ( States_Control the_states ) { return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
a000c6a4:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
 */                                                                   
                                                                      
bool _Thread_queue_Extract_with_proxy(                                
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
a000c6a8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000c6ac:	e3a00bef 	mov	r0, #244736	; 0x3bc00                         <== NOT EXECUTED
a000c6b0:	e2800e2e 	add	r0, r0, #736	; 0x2e0                          <== NOT EXECUTED
a000c6b4:	e0030000 	and	r0, r3, r0                                    <== NOT EXECUTED
  States_Control                state;                                
                                                                      
  state = the_thread->current_state;                                  
                                                                      
  if ( _States_Is_waiting_on_thread_queue( state ) ) {                
a000c6b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
 */                                                                   
                                                                      
bool _Thread_queue_Extract_with_proxy(                                
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
a000c6bc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  States_Control                state;                                
                                                                      
  state = the_thread->current_state;                                  
                                                                      
  if ( _States_Is_waiting_on_thread_queue( state ) ) {                
a000c6c0:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                <== NOT EXECUTED
                                                                      
        if ( proxy_extract_callout )                                  
          (*proxy_extract_callout)( the_thread );                     
      }                                                               
    #endif                                                            
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );      
a000c6c4:	e5910044 	ldr	r0, [r1, #68]	; 0x44                          <== NOT EXECUTED
a000c6c8:	eb000c58 	bl	a000f830 <_Thread_queue_Extract>               <== NOT EXECUTED
                                                                      
    return true;                                                      
a000c6cc:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
  }                                                                   
  return false;                                                       
}                                                                     
a000c6d0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00211a4 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
a00211a4:	e5901034 	ldr	r1, [r0, #52]	; 0x34                          <== NOT EXECUTED
      first_p = _Thread_queue_First_priority;                         
a00211a8:	e59f2014 	ldr	r2, [pc, #20]	; a00211c4 <_Thread_queue_First+0x20><== NOT EXECUTED
a00211ac:	e59f3014 	ldr	r3, [pc, #20]	; a00211c8 <_Thread_queue_First+0x24><== NOT EXECUTED
a00211b0:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
 */                                                                   
                                                                      
Thread_Control *_Thread_queue_First(                                  
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
a00211b4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Thread_Control * (*first_p)(Thread_queue_Control *);                
                                                                      
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
      first_p = _Thread_queue_First_priority;                         
a00211b8:	01a03002 	moveq	r3, r2                                      <== NOT EXECUTED
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */                     
      first_p = _Thread_queue_First_fifo;                             
                                                                      
  return (*first_p)( the_thread_queue );                              
a00211bc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a00211c0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00226d4 <_Thread_queue_First_fifo>: { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; }
a00226d4:	e4903004 	ldr	r3, [r0], #4                                  <== NOT EXECUTED
a00226d8:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
a00226dc:	11a00003 	movne	r0, r3                                      <== NOT EXECUTED
a00226e0:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
a00226e4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00211cc <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) {
a00211cc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00211d0:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
  uint32_t   index;                                                   
                                                                      
  for( index=0 ;                                                      
a00211d4:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a00211d8:	e3a0400c 	mov	r4, #12                                       <== NOT EXECUTED
a00211dc:	e00c0294 	mul	ip, r4, r2                                    <== NOT EXECUTED
      return (Thread_Control *) _Chain_First(                         
        &the_thread_queue->Queues.Priority[ index ]                   
      );                                                              
  }                                                                   
  return NULL;                                                        
}                                                                     
a00211e0:	e7901003 	ldr	r1, [r0, r3]                                  <== NOT EXECUTED
a00211e4:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
a00211e8:	e080c00c 	add	ip, r0, ip                                    <== NOT EXECUTED
  uint32_t   index;                                                   
                                                                      
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
a00211ec:	e151000c 	cmp	r1, ip                                        <== NOT EXECUTED
{                                                                     
  uint32_t   index;                                                   
                                                                      
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
a00211f0:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
a00211f4:	1a000005 	bne	a0021210 <_Thread_queue_First_priority+0x44>  <== NOT EXECUTED
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  uint32_t   index;                                                   
                                                                      
  for( index=0 ;                                                      
a00211f8:	e3520004 	cmp	r2, #4                                        <== NOT EXECUTED
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
a00211fc:	e283300c 	add	r3, r3, #12                                   <== NOT EXECUTED
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  uint32_t   index;                                                   
                                                                      
  for( index=0 ;                                                      
a0021200:	1afffff5 	bne	a00211dc <_Thread_queue_First_priority+0x10>  <== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
      return (Thread_Control *) _Chain_First(                         
        &the_thread_queue->Queues.Priority[ index ]                   
      );                                                              
  }                                                                   
  return NULL;                                                        
a0021204:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0021208:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a002120c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      
  for( index=0 ;                                                      
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;           
       index++ ) {                                                    
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
      return (Thread_Control *) _Chain_First(                         
a0021210:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0021214:	eafffffb 	b	a0021208 <_Thread_queue_First_priority+0x3c>    <== NOT EXECUTED
                                                                      

a000c6d4 <_Thread_queue_Flush>: #else Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)), #endif uint32_t status ) {
a000c6d4:	e92d4030 	push	{r4, r5, lr}                                 
a000c6d8:	e1a04000 	mov	r4, r0                                        
a000c6dc:	e1a05002 	mov	r5, r2                                        
  Thread_Control *the_thread;                                         
                                                                      
  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
a000c6e0:	ea000000 	b	a000c6e8 <_Thread_queue_Flush+0x14>             
#if defined(RTEMS_MULTIPROCESSING)                                    
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      ( *remote_extract_callout )( the_thread );                      
    else                                                              
#endif                                                                
      the_thread->Wait.return_code = status;                          
a000c6e4:	e5805034 	str	r5, [r0, #52]	; 0x34                          <== NOT EXECUTED
  uint32_t                    status                                  
)                                                                     
{                                                                     
  Thread_Control *the_thread;                                         
                                                                      
  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
a000c6e8:	e1a00004 	mov	r0, r4                                        
a000c6ec:	ebfffef6 	bl	a000c2cc <_Thread_queue_Dequeue>               
a000c6f0:	e3500000 	cmp	r0, #0                                        
a000c6f4:	1afffffa 	bne	a000c6e4 <_Thread_queue_Flush+0x10>           
      ( *remote_extract_callout )( the_thread );                      
    else                                                              
#endif                                                                
      the_thread->Wait.return_code = status;                          
  }                                                                   
}                                                                     
a000c6f8:	e8bd8030 	pop	{r4, r5, pc}                                  
                                                                      

a000f938 <_Thread_queue_Process_timeout>: #include <rtems/score/tqdata.h> void _Thread_queue_Process_timeout( Thread_Control *the_thread ) {
a000f938:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;    
a000f93c:	e5900044 	ldr	r0, [r0, #68]	; 0x44                          <== NOT EXECUTED
   *  If it is not satisfied, then it is "nothing happened" and       
   *  this is the "timeout" transition.  After a request is satisfied,
   *  a timeout is not allowed to occur.                              
   */                                                                 
                                                                      
  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
a000f940:	e5902030 	ldr	r2, [r0, #48]	; 0x30                          <== NOT EXECUTED
a000f944:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000f948:	0a000003 	beq	a000f95c <_Thread_queue_Process_timeout+0x24> <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
a000f94c:	e59f1034 	ldr	r1, [pc, #52]	; a000f988 <_Thread_queue_Process_timeout+0x50><== NOT EXECUTED
a000f950:	e5911004 	ldr	r1, [r1, #4]                                  <== NOT EXECUTED
a000f954:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a000f958:	0a000003 	beq	a000f96c <_Thread_queue_Process_timeout+0x34> <== NOT EXECUTED
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
    }                                                                 
  } else {                                                            
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
a000f95c:	e590203c 	ldr	r2, [r0, #60]	; 0x3c                          <== NOT EXECUTED
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );      
a000f960:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
    }                                                                 
  } else {                                                            
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
a000f964:	e5832034 	str	r2, [r3, #52]	; 0x34                          <== NOT EXECUTED
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );      
a000f968:	eaffffb0 	b	a000f830 <_Thread_queue_Extract>                <== NOT EXECUTED
   *  a timeout is not allowed to occur.                              
   */                                                                 
                                                                      
  if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
       _Thread_Is_executing( the_thread ) ) {                         
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
a000f96c:	e3520003 	cmp	r2, #3                                        <== NOT EXECUTED
a000f970:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
a000f974:	e590203c 	ldr	r2, [r0, #60]	; 0x3c                          <== NOT EXECUTED
a000f978:	e5832034 	str	r2, [r3, #52]	; 0x34                          <== NOT EXECUTED
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
a000f97c:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
a000f980:	e5803030 	str	r3, [r0, #48]	; 0x30                          <== NOT EXECUTED
a000f984:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000c768 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
a000c768:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  /*                                                                  
   * Just in case the thread really wasn't blocked on a thread queue  
   * when we get here.                                                
   */                                                                 
  if ( !the_thread_queue )                                            
a000c76c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
                                                                      
void _Thread_queue_Requeue(                                           
  Thread_queue_Control *the_thread_queue,                             
  Thread_Control       *the_thread                                    
)                                                                     
{                                                                     
a000c770:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000c774:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  /*                                                                  
   * Just in case the thread really wasn't blocked on a thread queue  
   * when we get here.                                                
   */                                                                 
  if ( !the_thread_queue )                                            
a000c778:	0a000002 	beq	a000c788 <_Thread_queue_Requeue+0x20>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If queueing by FIFO, there is nothing to do. This only applies to
   * priority blocking discipline.                                    
   */                                                                 
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
a000c77c:	e5943034 	ldr	r3, [r4, #52]	; 0x34                          <== NOT EXECUTED
a000c780:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a000c784:	0a000001 	beq	a000c790 <_Thread_queue_Requeue+0x28>         <== NOT EXECUTED
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
    }                                                                 
    _ISR_Enable( level );                                             
  }                                                                   
}                                                                     
a000c788:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000c78c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000c790:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a000c794:	e3862080 	orr	r2, r6, #128	; 0x80                           <== NOT EXECUTED
a000c798:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
a000c79c:	e591c010 	ldr	ip, [r1, #16]                                 <== NOT EXECUTED
a000c7a0:	e3a02bef 	mov	r2, #244736	; 0x3bc00                         <== NOT EXECUTED
a000c7a4:	e2822e2e 	add	r2, r2, #736	; 0x2e0                          <== NOT EXECUTED
a000c7a8:	e00c2002 	and	r2, ip, r2                                    <== NOT EXECUTED
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
a000c7ac:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000c7b0:	1a000001 	bne	a000c7bc <_Thread_queue_Requeue+0x54>         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000c7b4:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
a000c7b8:	eafffff2 	b	a000c788 <_Thread_queue_Requeue+0x20>           <== NOT EXECUTED
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
a000c7bc:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a000c7c0:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
a000c7c4:	eb000c1f 	bl	a000f848 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
a000c7c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000c7cc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000c7d0:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000c7d4:	ebffff45 	bl	a000c4f0 <_Thread_queue_Enqueue_priority>      <== NOT EXECUTED
a000c7d8:	eafffff5 	b	a000c7b4 <_Thread_queue_Requeue+0x4c>           <== NOT EXECUTED
                                                                      

a000c7dc <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) {
a000c7dc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a000c7e0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000c7e4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000c7e8:	ebfffe01 	bl	a000bff4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000c7ec:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000c7f0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c7f4:	1a000004 	bne	a000c80c <_Thread_queue_Timeout+0x30>         <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
a000c7f8:	eb000c4e 	bl	a000f938 <_Thread_queue_Process_timeout>       <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )             
{                                                                     
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
  _Thread_Dispatch_disable_level -= 1;                                
a000c7fc:	e59f3010 	ldr	r3, [pc, #16]	; a000c814 <_Thread_queue_Timeout+0x38><== NOT EXECUTED
a000c800:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000c804:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a000c808:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
      _Thread_Unnest_dispatch();                                      
      break;                                                          
  }                                                                   
}                                                                     
a000c80c:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000c810:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a001a384 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
a001a384:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a001a388:	e24dd024 	sub	sp, sp, #36	; 0x24                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a38c:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
a001a390:	e28d700c 	add	r7, sp, #12                                   <== NOT EXECUTED
a001a394:	e281b004 	add	fp, r1, #4                                    <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
a001a398:	e58d1020 	str	r1, [sp, #32]                                 <== NOT EXECUTED
a001a39c:	e59fa1d4 	ldr	sl, [pc, #468]	; a001a578 <_Timer_server_Body+0x1f4><== NOT EXECUTED
a001a3a0:	e2801008 	add	r1, r0, #8                                    <== NOT EXECUTED
a001a3a4:	e59f91d0 	ldr	r9, [pc, #464]	; a001a57c <_Timer_server_Body+0x1f8><== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
a001a3a8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a3ac:	e2872004 	add	r2, r7, #4                                    <== NOT EXECUTED
a001a3b0:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
a001a3b4:	e2801040 	add	r1, r0, #64	; 0x40                            <== NOT EXECUTED
a001a3b8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a001a3bc:	e58db018 	str	fp, [sp, #24]                                 <== NOT EXECUTED
  head->previous = NULL;                                              
a001a3c0:	e58d301c 	str	r3, [sp, #28]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a3c4:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
  head->previous = NULL;                                              
a001a3c8:	e58d3010 	str	r3, [sp, #16]                                 <== NOT EXECUTED
  tail->previous = head;                                              
a001a3cc:	e58d7014 	str	r7, [sp, #20]                                 <== NOT EXECUTED
a001a3d0:	e2806030 	add	r6, r0, #48	; 0x30                            <== NOT EXECUTED
a001a3d4:	e2808068 	add	r8, r0, #104	; 0x68                           <== NOT EXECUTED
a001a3d8:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(         
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return &the_chain->Tail.Node;                                       
a001a3dc:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
{                                                                     
  /*                                                                  
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.       
   */                                                                 
  ts->insert_chain = insert_chain;                                    
a001a3e0:	e28d2018 	add	r2, sp, #24                                   <== NOT EXECUTED
a001a3e4:	e5842078 	str	r2, [r4, #120]	; 0x78                         <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
a001a3e8:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
a001a3ec:	e594103c 	ldr	r1, [r4, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
a001a3f0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a001a3f4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
a001a3f8:	e584303c 	str	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
a001a3fc:	e0611003 	rsb	r1, r1, r3                                    <== NOT EXECUTED
a001a400:	eb001155 	bl	a001e95c <_Watchdog_Adjust_to_chain>           <== NOT EXECUTED
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a001a404:	e5995000 	ldr	r5, [r9]                                      <== NOT EXECUTED
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
a001a408:	e5942074 	ldr	r2, [r4, #116]	; 0x74                         <== NOT EXECUTED
  /*                                                                  
   *  Process the seconds chain.  Start by checking that the Time     
   *  of Day (TOD) has not been set backwards.  If it has then        
   *  we want to adjust the watchdogs->Chain to indicate this.        
   */                                                                 
  if ( snapshot > last_snapshot ) {                                   
a001a40c:	e1550002 	cmp	r5, r2                                        <== NOT EXECUTED
a001a410:	8a000022 	bhi	a001a4a0 <_Timer_server_Body+0x11c>           <== NOT EXECUTED
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
a001a414:	3a000018 	bcc	a001a47c <_Timer_server_Body+0xf8>            <== NOT EXECUTED
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
a001a418:	e5845074 	str	r5, [r4, #116]	; 0x74                         <== NOT EXECUTED
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
a001a41c:	e5940078 	ldr	r0, [r4, #120]	; 0x78                         <== NOT EXECUTED
a001a420:	eb0002c2 	bl	a001af30 <_Chain_Get>                          <== NOT EXECUTED
                                                                      
    if ( timer == NULL ) {                                            
a001a424:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a001a428:	0a00000b 	beq	a001a45c <_Timer_server_Body+0xd8>            <== NOT EXECUTED
static void _Timer_server_Insert_timer(                               
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
a001a42c:	e5913038 	ldr	r3, [r1, #56]	; 0x38                          <== NOT EXECUTED
a001a430:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a001a434:	0a000015 	beq	a001a490 <_Timer_server_Body+0x10c>           <== NOT EXECUTED
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
a001a438:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a001a43c:	1afffff6 	bne	a001a41c <_Timer_server_Body+0x98>            <== NOT EXECUTED
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
a001a440:	e2811010 	add	r1, r1, #16                                   <== NOT EXECUTED
a001a444:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a001a448:	eb00116e 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
a001a44c:	e5940078 	ldr	r0, [r4, #120]	; 0x78                         <== NOT EXECUTED
a001a450:	eb0002b6 	bl	a001af30 <_Chain_Get>                          <== NOT EXECUTED
                                                                      
    if ( timer == NULL ) {                                            
a001a454:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a001a458:	1afffff3 	bne	a001a42c <_Timer_server_Body+0xa8>            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a45c:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a001a460:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a001a464:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
a001a468:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
a001a46c:	e153000b 	cmp	r3, fp                                        <== NOT EXECUTED
a001a470:	0a00000f 	beq	a001a4b4 <_Timer_server_Body+0x130>           <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a474:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
a001a478:	eaffffda 	b	a001a3e8 <_Timer_server_Body+0x64>              <== NOT EXECUTED
     /*                                                               
      *  The current TOD is before the last TOD which indicates that  
      *  TOD has been set backwards.                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
a001a47c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a001a480:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a001a484:	e0652002 	rsb	r2, r5, r2                                    <== NOT EXECUTED
a001a488:	eb001102 	bl	a001e898 <_Watchdog_Adjust>                    <== NOT EXECUTED
a001a48c:	eaffffe1 	b	a001a418 <_Timer_server_Body+0x94>              <== NOT EXECUTED
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
a001a490:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a001a494:	e2811010 	add	r1, r1, #16                                   <== NOT EXECUTED
a001a498:	eb00115a 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
a001a49c:	eaffffde 	b	a001a41c <_Timer_server_Body+0x98>              <== NOT EXECUTED
    /*                                                                
     *  This path is for normal forward movement and cases where the  
     *  TOD has been set forward.                                     
     */                                                               
    delta = snapshot - last_snapshot;                                 
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a001a4a0:	e0621005 	rsb	r1, r2, r5                                    <== NOT EXECUTED
a001a4a4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a001a4a8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a001a4ac:	eb00112a 	bl	a001e95c <_Watchdog_Adjust_to_chain>           <== NOT EXECUTED
a001a4b0:	eaffffd8 	b	a001a418 <_Timer_server_Body+0x94>              <== NOT EXECUTED
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
      ts->insert_chain = NULL;                                        
a001a4b4:	e5841078 	str	r1, [r4, #120]	; 0x78                         <== NOT EXECUTED
a001a4b8:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  _Chain_Initialize_empty( &fire_chain );                             
                                                                      
  while ( true ) {                                                    
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
                                                                      
    if ( !_Chain_Is_empty( &fire_chain ) ) {                          
a001a4bc:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a001a4c0:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
a001a4c4:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a001a4c8:	0a000015 	beq	a001a524 <_Timer_server_Body+0x1a0>           <== NOT EXECUTED
a001a4cc:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
a001a4d0:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a001a4d4:	ea000009 	b	a001a500 <_Timer_server_Body+0x17c>             <== NOT EXECUTED
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
a001a4d8:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
                                                                      
  head->next = new_first;                                             
  new_first->previous = head;                                         
a001a4dc:	e5837004 	str	r7, [r3, #4]                                  <== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *old_first = head->next;                                 
  Chain_Node *new_first = old_first->next;                            
                                                                      
  head->next = new_first;                                             
a001a4e0:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
a001a4e4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a001a4e8:	e5823008 	str	r3, [r2, #8]                                  <== NOT EXECUTED
a001a4ec:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
        /*                                                            
         *  The timer server may block here and wait for resources or time.
         *  The system watchdogs are inactive and will remain inactive since
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
a001a4f0:	e592301c 	ldr	r3, [r2, #28]                                 <== NOT EXECUTED
a001a4f4:	e5920020 	ldr	r0, [r2, #32]                                 <== NOT EXECUTED
a001a4f8:	e5921024 	ldr	r1, [r2, #36]	; 0x24                          <== NOT EXECUTED
a001a4fc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a500:	e10f1000 	mrs	r1, CPSR                                      <== NOT EXECUTED
a001a504:	e3813080 	orr	r3, r1, #128	; 0x80                           <== NOT EXECUTED
a001a508:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a50c:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
a001a510:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a001a514:	1affffef 	bne	a001a4d8 <_Timer_server_Body+0x154>           <== NOT EXECUTED
a001a518:	e1a04005 	mov	r4, r5                                        <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a51c:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
a001a520:	eaffffae 	b	a001a3e0 <_Timer_server_Body+0x5c>              <== NOT EXECUTED
a001a524:	e59f2054 	ldr	r2, [pc, #84]	; a001a580 <_Timer_server_Body+0x1fc><== NOT EXECUTED
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
a001a528:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a001a52c:	e5c4107c 	strb	r1, [r4, #124]	; 0x7c                        <== NOT EXECUTED
a001a530:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
a001a534:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a001a538:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
a001a53c:	e3a01008 	mov	r1, #8                                        <== NOT EXECUTED
a001a540:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a001a544:	eb000f43 	bl	a001e258 <_Thread_Set_state>                   <== NOT EXECUTED
        _Timer_server_Reset_interval_system_watchdog( ts );           
a001a548:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001a54c:	ebffff60 	bl	a001a2d4 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
        _Timer_server_Reset_tod_system_watchdog( ts );                
a001a550:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001a554:	ebffff74 	bl	a001a32c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a001a558:	eb000d08 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
                                                                      
      ts->active = true;                                              
a001a55c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a001a560:	e5c4307c 	strb	r3, [r4, #124]	; 0x7c                        <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
a001a564:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
a001a568:	eb001195 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
a001a56c:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
a001a570:	eb001193 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
a001a574:	eaffff99 	b	a001a3e0 <_Timer_server_Body+0x5c>              <== NOT EXECUTED
                                                                      

a001a2d4 <_Timer_server_Reset_interval_system_watchdog>: } static void _Timer_server_Reset_interval_system_watchdog( Timer_server_Control *ts ) {
a001a2d4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
a001a2d8:	e2805008 	add	r5, r0, #8                                    <== NOT EXECUTED
}                                                                     
                                                                      
static void _Timer_server_Reset_interval_system_watchdog(             
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
a001a2dc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
a001a2e0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001a2e4:	eb001236 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a2e8:	e10f1000 	mrs	r1, CPSR                                      <== NOT EXECUTED
a001a2ec:	e3813080 	orr	r3, r1, #128	; 0x80                           <== NOT EXECUTED
a001a2f0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a2f4:	e5943030 	ldr	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a001a2f8:	e2842034 	add	r2, r4, #52	; 0x34                            <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _Timer_server_Stop_interval_system_watchdog( ts );                  
                                                                      
  _ISR_Disable( level );                                              
  if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {          
a001a2fc:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a001a300:	0a000006 	beq	a001a320 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED
    Watchdog_Interval delta_interval =                                
a001a304:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a308:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a001a30c:	e59f0014 	ldr	r0, [pc, #20]	; a001a328 <_Timer_server_Reset_interval_system_watchdog+0x54><== NOT EXECUTED
a001a310:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a001a314:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
      delta_interval                                                  
    );                                                                
  } else {                                                            
    _ISR_Enable( level );                                             
  }                                                                   
}                                                                     
a001a318:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a001a31c:	ea0011b9 	b	a001ea08 <_Watchdog_Insert>                     <== NOT EXECUTED
a001a320:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
a001a324:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a001a32c <_Timer_server_Reset_tod_system_watchdog>: } static void _Timer_server_Reset_tod_system_watchdog( Timer_server_Control *ts ) {
a001a32c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
a001a330:	e2805040 	add	r5, r0, #64	; 0x40                            <== NOT EXECUTED
}                                                                     
                                                                      
static void _Timer_server_Reset_tod_system_watchdog(                  
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
a001a334:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
a001a338:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001a33c:	eb001220 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a340:	e10f1000 	mrs	r1, CPSR                                      <== NOT EXECUTED
a001a344:	e3813080 	orr	r3, r1, #128	; 0x80                           <== NOT EXECUTED
a001a348:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a34c:	e5943068 	ldr	r3, [r4, #104]	; 0x68                         <== NOT EXECUTED
a001a350:	e284206c 	add	r2, r4, #108	; 0x6c                           <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _Timer_server_Stop_tod_system_watchdog( ts );                       
                                                                      
  _ISR_Disable( level );                                              
  if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {               
a001a354:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a001a358:	0a000006 	beq	a001a378 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED
    Watchdog_Interval delta_interval =                                
a001a35c:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a360:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a001a364:	e59f0014 	ldr	r0, [pc, #20]	; a001a380 <_Timer_server_Reset_tod_system_watchdog+0x54><== NOT EXECUTED
a001a368:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a001a36c:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
      delta_interval                                                  
    );                                                                
  } else {                                                            
    _ISR_Enable( level );                                             
  }                                                                   
}                                                                     
a001a370:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a001a374:	ea0011a3 	b	a001ea08 <_Watchdog_Insert>                     <== NOT EXECUTED
a001a378:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
a001a37c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a001a584 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { if ( ts->insert_chain == NULL ) {
a001a584:	e5902078 	ldr	r2, [r0, #120]	; 0x78                         <== NOT EXECUTED
                                                                      
static void _Timer_server_Schedule_operation_method(                  
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
a001a588:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if ( ts->insert_chain == NULL ) {                                   
a001a58c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
                                                                      
static void _Timer_server_Schedule_operation_method(                  
  Timer_server_Control *ts,                                           
  Timer_Control *timer                                                
)                                                                     
{                                                                     
a001a590:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a001a594:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  if ( ts->insert_chain == NULL ) {                                   
a001a598:	0a000002 	beq	a001a5a8 <_Timer_server_Schedule_operation_method+0x24><== NOT EXECUTED
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.         
     */                                                               
    _Chain_Append( ts->insert_chain, &timer->Object.Node );           
a001a59c:	e5900078 	ldr	r0, [r0, #120]	; 0x78                         <== NOT EXECUTED
  }                                                                   
}                                                                     
a001a5a0:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.         
     */                                                               
    _Chain_Append( ts->insert_chain, &timer->Object.Node );           
a001a5a4:	ea00024e 	b	a001aee4 <_Chain_Append>                        <== NOT EXECUTED
a001a5a8:	e59f1104 	ldr	r1, [pc, #260]	; a001a6b4 <_Timer_server_Schedule_operation_method+0x130><== NOT EXECUTED
a001a5ac:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
a001a5b0:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a001a5b4:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
a001a5b8:	e5931038 	ldr	r1, [r3, #56]	; 0x38                          <== NOT EXECUTED
a001a5bc:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
a001a5c0:	0a000021 	beq	a001a64c <_Timer_server_Schedule_operation_method+0xc8><== NOT EXECUTED
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
                                                                      
    if ( !ts->active ) {                                              
      _Timer_server_Reset_interval_system_watchdog( ts );             
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
a001a5c4:	e3510003 	cmp	r1, #3                                        <== NOT EXECUTED
a001a5c8:	0a000001 	beq	a001a5d4 <_Timer_server_Schedule_operation_method+0x50><== NOT EXECUTED
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.         
     */                                                               
    _Chain_Append( ts->insert_chain, &timer->Object.Node );           
  }                                                                   
}                                                                     
a001a5cc:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
a001a5d0:	ea000cea 	b	a001d980 <_Thread_Enable_dispatch>              <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a5d4:	e10fe000 	mrs	lr, CPSR                                      <== NOT EXECUTED
a001a5d8:	e38e1080 	orr	r1, lr, #128	; 0x80                           <== NOT EXECUTED
a001a5dc:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a5e0:	e5941068 	ldr	r1, [r4, #104]	; 0x68                         <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a001a5e4:	e284006c 	add	r0, r4, #108	; 0x6c                           <== NOT EXECUTED
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
a001a5e8:	e594c074 	ldr	ip, [r4, #116]	; 0x74                         <== NOT EXECUTED
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
a001a5ec:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
a001a5f0:	e59f00c0 	ldr	r0, [pc, #192]	; a001a6b8 <_Timer_server_Schedule_operation_method+0x134><== NOT EXECUTED
a001a5f4:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
a001a5f8:	0a000008 	beq	a001a620 <_Timer_server_Schedule_operation_method+0x9c><== NOT EXECUTED
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
a001a5fc:	e5915010 	ldr	r5, [r1, #16]                                 <== NOT EXECUTED
      if ( snapshot > last_snapshot ) {                               
a001a600:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
a001a604:	9085200c 	addls	r2, r5, ip                                  <== NOT EXECUTED
        delta_interval += delta;                                      
a001a608:	90602002 	rsbls	r2, r0, r2                                  <== NOT EXECUTED
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );   
      delta_interval = first_watchdog->delta_interval;                
      if ( snapshot > last_snapshot ) {                               
a001a60c:	9a000002 	bls	a001a61c <_Timer_server_Schedule_operation_method+0x98><== NOT EXECUTED
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
a001a610:	e06cc000 	rsb	ip, ip, r0                                    <== NOT EXECUTED
        if (delta_interval > delta) {                                 
a001a614:	e155000c 	cmp	r5, ip                                        <== NOT EXECUTED
          delta_interval -= delta;                                    
a001a618:	806c2005 	rsbhi	r2, ip, r5                                  <== NOT EXECUTED
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
        delta_interval += delta;                                      
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
a001a61c:	e5812010 	str	r2, [r1, #16]                                 <== NOT EXECUTED
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
a001a620:	e5840074 	str	r0, [r4, #116]	; 0x74                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a624:	e129f00e 	msr	CPSR_fc, lr                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
a001a628:	e2831010 	add	r1, r3, #16                                   <== NOT EXECUTED
a001a62c:	e2840068 	add	r0, r4, #104	; 0x68                           <== NOT EXECUTED
a001a630:	eb0010f4 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
                                                                      
    if ( !ts->active ) {                                              
a001a634:	e5d4307c 	ldrb	r3, [r4, #124]	; 0x7c                        <== NOT EXECUTED
a001a638:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a001a63c:	1affffe2 	bne	a001a5cc <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
      _Timer_server_Reset_tod_system_watchdog( ts );                  
a001a640:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001a644:	ebffff38 	bl	a001a32c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
a001a648:	eaffffdf 	b	a001a5cc <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a64c:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a001a650:	e3851080 	orr	r1, r5, #128	; 0x80                           <== NOT EXECUTED
a001a654:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a658:	e5941030 	ldr	r1, [r4, #48]	; 0x30                          <== NOT EXECUTED
a001a65c:	e2840034 	add	r0, r4, #52	; 0x34                            <== NOT EXECUTED
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
a001a660:	e1510000 	cmp	r1, r0                                        <== NOT EXECUTED
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
a001a664:	e59f0050 	ldr	r0, [pc, #80]	; a001a6bc <_Timer_server_Schedule_operation_method+0x138><== NOT EXECUTED
a001a668:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
a001a66c:	e594c03c 	ldr	ip, [r4, #60]	; 0x3c                          <== NOT EXECUTED
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
a001a670:	0a000004 	beq	a001a688 <_Timer_server_Schedule_operation_method+0x104><== NOT EXECUTED
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
a001a674:	e591e010 	ldr	lr, [r1, #16]                                 <== NOT EXECUTED
      first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
                                                                      
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
a001a678:	e06cc000 	rsb	ip, ip, r0                                    <== NOT EXECUTED
                                                                      
      delta_interval = first_watchdog->delta_interval;                
      if (delta_interval > delta) {                                   
a001a67c:	e15c000e 	cmp	ip, lr                                        <== NOT EXECUTED
        delta_interval -= delta;                                      
a001a680:	306c200e 	rsbcc	r2, ip, lr                                  <== NOT EXECUTED
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
a001a684:	e5812010 	str	r2, [r1, #16]                                 <== NOT EXECUTED
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
a001a688:	e584003c 	str	r0, [r4, #60]	; 0x3c                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a68c:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
    _ISR_Enable( level );                                             
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
a001a690:	e2831010 	add	r1, r3, #16                                   <== NOT EXECUTED
a001a694:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
a001a698:	eb0010da 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
                                                                      
    if ( !ts->active ) {                                              
a001a69c:	e5d4307c 	ldrb	r3, [r4, #124]	; 0x7c                        <== NOT EXECUTED
a001a6a0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a001a6a4:	1affffc8 	bne	a001a5cc <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
      _Timer_server_Reset_interval_system_watchdog( ts );             
a001a6a8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001a6ac:	ebffff08 	bl	a001a2d4 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
a001a6b0:	eaffffc5 	b	a001a5cc <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
                                                                      

a000ca50 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) {
a000ca50:	e1a03000 	mov	r3, r0                                        
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
a000ca54:	e5902004 	ldr	r2, [r0, #4]                                  
                                                                      
uint32_t _Timespec_Add_to(                                            
  struct timespec       *time,                                        
  const struct timespec *add                                          
)                                                                     
{                                                                     
a000ca58:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
a000ca5c:	e8910011 	ldm	r1, {r0, r4}                                  
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
a000ca60:	e59fc040 	ldr	ip, [pc, #64]	; a000caa8 <_Timespec_Add_to+0x58>
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
a000ca64:	e5931000 	ldr	r1, [r3]                                      
  time->tv_nsec += add->tv_nsec;                                      
a000ca68:	e0844002 	add	r4, r4, r2                                    
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
a000ca6c:	e154000c 	cmp	r4, ip                                        
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
a000ca70:	e0811000 	add	r1, r1, r0                                    
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
a000ca74:	e1a02004 	mov	r2, r4                                        
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
a000ca78:	e8830012 	stm	r3, {r1, r4}                                  
  time->tv_nsec += add->tv_nsec;                                      
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
a000ca7c:	9a000007 	bls	a000caa0 <_Timespec_Add_to+0x50>              
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
a000ca80:	e2822331 	add	r2, r2, #-1006632960	; 0xc4000000             <== NOT EXECUTED
a000ca84:	e2822865 	add	r2, r2, #6619136	; 0x650000                   <== NOT EXECUTED
a000ca88:	e2822c36 	add	r2, r2, #13824	; 0x3600                       <== NOT EXECUTED
  /* 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 ) {             
a000ca8c:	e152000c 	cmp	r2, ip                                        <== NOT EXECUTED
 *                                                                    
 *  This routines adds two timespecs.  The second argument is added   
 *  to the first.                                                     
 */                                                                   
                                                                      
uint32_t _Timespec_Add_to(                                            
a000ca90:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
                                                                      
  /* Now adjust it so nanoseconds is in range */                      
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {             
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
    time->tv_sec++;                                                   
    seconds++;                                                        
a000ca94:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
  /* 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 ) {             
a000ca98:	8afffff8 	bhi	a000ca80 <_Timespec_Add_to+0x30>              <== NOT EXECUTED
a000ca9c:	e8830006 	stm	r3, {r1, r2}                                  <== NOT EXECUTED
    time->tv_sec++;                                                   
    seconds++;                                                        
  }                                                                   
                                                                      
  return seconds;                                                     
}                                                                     
a000caa0:	e8bd0010 	pop	{r4}                                          
a000caa4:	e12fff1e 	bx	lr                                             
                                                                      

a000e68c <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) {
a000e68c:	e92d4bf0 	push	{r4, r5, r6, r7, r8, r9, fp, lr}             <== NOT EXECUTED
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  right += rhs->tv_nsec;                                              
a000e690:	e5916004 	ldr	r6, [r1, #4]                                  <== NOT EXECUTED
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
a000e694:	e591c000 	ldr	ip, [r1]                                      <== NOT EXECUTED
a000e698:	e59f1084 	ldr	r1, [pc, #132]	; a000e724 <_Timespec_Divide+0x98><== NOT EXECUTED
  right += rhs->tv_nsec;                                              
a000e69c:	e1a07fc6 	asr	r7, r6, #31                                   <== NOT EXECUTED
  const struct timespec *lhs,                                         
  const struct timespec *rhs,                                         
  uint32_t              *ival_percentage,                             
  uint32_t              *fval_percentage                              
)                                                                     
{                                                                     
a000e6a0:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  right += rhs->tv_nsec;                                              
a000e6a4:	e0e76c91 	smlal	r6, r7, r1, ip                              <== NOT EXECUTED
  const struct timespec *lhs,                                         
  const struct timespec *rhs,                                         
  uint32_t              *ival_percentage,                             
  uint32_t              *fval_percentage                              
)                                                                     
{                                                                     
a000e6a8:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  right += rhs->tv_nsec;                                              
                                                                      
  if ( right == 0 ) {                                                 
a000e6ac:	e1962007 	orrs	r2, r6, r7                                   <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
a000e6b0:	e8900808 	ldm	r0, {r3, fp}                                  <== NOT EXECUTED
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  right += rhs->tv_nsec;                                              
                                                                      
  if ( right == 0 ) {                                                 
a000e6b4:	0a000017 	beq	a000e718 <_Timespec_Divide+0x8c>              <== NOT EXECUTED
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  left   = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  left  += lhs->tv_nsec;                                              
a000e6b8:	e1a0cfcb 	asr	ip, fp, #31                                   <== NOT EXECUTED
a000e6bc:	e0ecb391 	smlal	fp, ip, r1, r3                              <== NOT EXECUTED
   *  Put it back in the timespec result.                             
   *                                                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (left * 100000) / right;                                   
a000e6c0:	e3a01b61 	mov	r1, #99328	; 0x18400                          <== NOT EXECUTED
a000e6c4:	e2811e2a 	add	r1, r1, #672	; 0x2a0                          <== NOT EXECUTED
a000e6c8:	e089819b 	umull	r8, r9, fp, r1                              <== NOT EXECUTED
a000e6cc:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000e6d0:	e0299c91 	mla	r9, r1, ip, r9                                <== NOT EXECUTED
a000e6d4:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a000e6d8:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000e6dc:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
a000e6e0:	eb003d27 	bl	a001db84 <__udivdi3>                           <== NOT EXECUTED
                                                                      
  *ival_percentage = answer / 1000;                                   
a000e6e4:	e3a02ffa 	mov	r2, #1000	; 0x3e8                             <== NOT EXECUTED
a000e6e8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   *  Put it back in the timespec result.                             
   *                                                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (left * 100000) / right;                                   
a000e6ec:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a000e6f0:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
                                                                      
  *ival_percentage = answer / 1000;                                   
a000e6f4:	eb003d22 	bl	a001db84 <__udivdi3>                           <== NOT EXECUTED
  *fval_percentage = answer % 1000;                                   
a000e6f8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (left * 100000) / right;                                   
                                                                      
  *ival_percentage = answer / 1000;                                   
a000e6fc:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
  *fval_percentage = answer % 1000;                                   
a000e700:	e3a02ffa 	mov	r2, #1000	; 0x3e8                             <== NOT EXECUTED
a000e704:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000e708:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000e70c:	eb003e2e 	bl	a001dfcc <__umoddi3>                           <== NOT EXECUTED
a000e710:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
a000e714:	e8bd8bf0 	pop	{r4, r5, r6, r7, r8, r9, fp, pc}              <== NOT EXECUTED
  left  += lhs->tv_nsec;                                              
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;        
  right += rhs->tv_nsec;                                              
                                                                      
  if ( right == 0 ) {                                                 
    *ival_percentage = 0;                                             
a000e718:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
    *fval_percentage = 0;                                             
a000e71c:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
    return;                                                           
a000e720:	e8bd8bf0 	pop	{r4, r5, r6, r7, r8, r9, fp, pc}              <== NOT EXECUTED
                                                                      

a000e6dc <_Timespec_Divide_by_integer>: /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec;
a000e6dc:	e590c000 	ldr	ip, [r0]                                      <== NOT EXECUTED
  t *= TOD_NANOSECONDS_PER_SECOND;                                    
a000e6e0:	e59f3068 	ldr	r3, [pc, #104]	; a000e750 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
void _Timespec_Divide_by_integer(                                     
  const struct timespec *time,                                        
  uint32_t               iterations,                                  
  struct timespec       *result                                       
)                                                                     
{                                                                     
a000e6e4:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  t  = time->tv_sec;                                                  
  t *= TOD_NANOSECONDS_PER_SECOND;                                    
a000e6e8:	e086539c 	umull	r5, r6, ip, r3                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  t  = time->tv_sec;                                                  
a000e6ec:	e1a0700c 	mov	r7, ip                                        <== NOT EXECUTED
a000e6f0:	e1a08fc7 	asr	r8, r7, #31                                   <== NOT EXECUTED
  t *= TOD_NANOSECONDS_PER_SECOND;                                    
  t += time->tv_nsec;                                                 
a000e6f4:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
  /*                                                                  
   *  For math simplicity just convert the timespec to nanoseconds    
   *  in a 64-bit integer.                                            
   */                                                                 
  t  = time->tv_sec;                                                  
  t *= TOD_NANOSECONDS_PER_SECOND;                                    
a000e6f8:	e0266893 	mla	r6, r3, r8, r6                                <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Divide to get nanoseconds per iteration                         
   */                                                                 
                                                                      
  t /= iterations;                                                    
a000e6fc:	e0957000 	adds	r7, r5, r0                                   <== NOT EXECUTED
a000e700:	e0a68fc0 	adc	r8, r6, r0, asr #31                           <== NOT EXECUTED
void _Timespec_Divide_by_integer(                                     
  const struct timespec *time,                                        
  uint32_t               iterations,                                  
  struct timespec       *result                                       
)                                                                     
{                                                                     
a000e704:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Divide to get nanoseconds per iteration                         
   */                                                                 
                                                                      
  t /= iterations;                                                    
a000e708:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000e70c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000e710:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000e714:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000e718:	eb003b5f 	bl	a001d49c <__udivdi3>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Put it back in the timespec result                              
   */                                                                 
                                                                      
  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;                   
a000e71c:	e59f202c 	ldr	r2, [pc, #44]	; a000e750 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
a000e720:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Divide to get nanoseconds per iteration                         
   */                                                                 
                                                                      
  t /= iterations;                                                    
a000e724:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000e728:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Put it back in the timespec result                              
   */                                                                 
                                                                      
  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;                   
a000e72c:	eb003b5a 	bl	a001d49c <__udivdi3>                           <== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;                   
a000e730:	e59f2018 	ldr	r2, [pc, #24]	; a000e750 <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Put it back in the timespec result                              
   */                                                                 
                                                                      
  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;                   
a000e734:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;                   
a000e738:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000e73c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000e740:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000e744:	eb003c66 	bl	a001d8e4 <__umoddi3>                           <== NOT EXECUTED
a000e748:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
}                                                                     
a000e74c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a0021988 <_Timespec_From_ticks>: struct timespec *time ) { uint32_t usecs; usecs = ticks * rtems_configuration_get_microseconds_per_tick();
a0021988:	e59f2034 	ldr	r2, [pc, #52]	; a00219c4 <_Timespec_From_ticks+0x3c><== NOT EXECUTED
                                                                      
  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;                
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *             
a002198c:	e3a0393d 	mov	r3, #999424	; 0xf4000                         <== NOT EXECUTED
a0021990:	e2833d09 	add	r3, r3, #576	; 0x240                          <== NOT EXECUTED
  struct timespec *time                                               
)                                                                     
{                                                                     
  uint32_t    usecs;                                                  
                                                                      
  usecs = ticks * rtems_configuration_get_microseconds_per_tick();    
a0021994:	e592200c 	ldr	r2, [r2, #12]                                 <== NOT EXECUTED
a0021998:	e0020290 	mul	r2, r0, r2                                    <== NOT EXECUTED
                                                                      
  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;                
a002199c:	e59f0024 	ldr	r0, [pc, #36]	; a00219c8 <_Timespec_From_ticks+0x40><== NOT EXECUTED
a00219a0:	e080c092 	umull	ip, r0, r2, r0                              <== NOT EXECUTED
a00219a4:	e1a00920 	lsr	r0, r0, #18                                   <== NOT EXECUTED
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *             
a00219a8:	e0030390 	mul	r3, r0, r3                                    <== NOT EXECUTED
{                                                                     
  uint32_t    usecs;                                                  
                                                                      
  usecs = ticks * rtems_configuration_get_microseconds_per_tick();    
                                                                      
  time->tv_sec  = usecs / TOD_MICROSECONDS_PER_SECOND;                
a00219ac:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *             
a00219b0:	e0632002 	rsb	r2, r3, r2                                    <== NOT EXECUTED
a00219b4:	e3a03ffa 	mov	r3, #1000	; 0x3e8                             <== NOT EXECUTED
a00219b8:	e0020293 	mul	r2, r3, r2                                    <== NOT EXECUTED
a00219bc:	e5812004 	str	r2, [r1, #4]                                  <== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;                  
}                                                                     
a00219c0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000e754 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec )
a000e754:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
a000e758:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000e75c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    return true;                                                      
a000e760:	c3a00001 	movgt	r0, #1                                      <== NOT EXECUTED
bool _Timespec_Greater_than(                                          
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
  if ( lhs->tv_sec > rhs->tv_sec )                                    
a000e764:	c12fff1e 	bxgt	lr                                           <== NOT EXECUTED
    return true;                                                      
                                                                      
  if ( lhs->tv_sec < rhs->tv_sec )                                    
a000e768:	ba000005 	blt	a000e784 <_Timespec_Greater_than+0x30>        <== NOT EXECUTED
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
                                                                      
bool _Timespec_Greater_than(                                          
a000e76c:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
a000e770:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
a000e774:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000e778:	d3a00000 	movle	r0, #0                                      <== NOT EXECUTED
a000e77c:	c3a00001 	movgt	r0, #1                                      <== NOT EXECUTED
a000e780:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
{                                                                     
  if ( lhs->tv_sec > rhs->tv_sec )                                    
    return true;                                                      
                                                                      
  if ( lhs->tv_sec < rhs->tv_sec )                                    
    return false;                                                     
a000e784:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */                            
  if ( lhs->tv_nsec > rhs->tv_nsec )                                  
    return true;                                                      
                                                                      
  return false;                                                       
}                                                                     
a000e788:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00219cc <_Timespec_Is_valid>: bool _Timespec_Is_valid( const struct timespec *time ) { if ( !time )
a00219cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00219d0:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    return false;                                                     
                                                                      
  if ( time->tv_sec < 0 )                                             
a00219d4:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00219d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return false;                                                     
a00219dc:	b3a00000 	movlt	r0, #0                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( !time )                                                        
    return false;                                                     
                                                                      
  if ( time->tv_sec < 0 )                                             
a00219e0:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
    return false;                                                     
                                                                      
  if ( time->tv_nsec < 0 )                                            
a00219e4:	e5903004 	ldr	r3, [r0, #4]                                  <== NOT EXECUTED
a00219e8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00219ec:	ba000004 	blt	a0021a04 <_Timespec_Is_valid+0x38>            <== NOT EXECUTED
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
                                                                      
bool _Timespec_Is_valid(                                              
a00219f0:	e59f0014 	ldr	r0, [pc, #20]	; a0021a0c <_Timespec_Is_valid+0x40><== NOT EXECUTED
a00219f4:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
a00219f8:	83a00000 	movhi	r0, #0                                      <== NOT EXECUTED
a00219fc:	93a00001 	movls	r0, #1                                      <== NOT EXECUTED
a0021a00:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      
  if ( time->tv_sec < 0 )                                             
    return false;                                                     
                                                                      
  if ( time->tv_nsec < 0 )                                            
    return false;                                                     
a0021a04:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )                  
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
a0021a08:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000e78c <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec )
a000e78c:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
a000e790:	e5913000 	ldr	r3, [r1]                                      <== NOT EXECUTED
a000e794:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
    return true;                                                      
a000e798:	b3a00001 	movlt	r0, #1                                      <== NOT EXECUTED
bool _Timespec_Less_than(                                             
  const struct timespec *lhs,                                         
  const struct timespec *rhs                                          
)                                                                     
{                                                                     
  if ( lhs->tv_sec < rhs->tv_sec )                                    
a000e79c:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
    return true;                                                      
                                                                      
  if ( lhs->tv_sec > rhs->tv_sec )                                    
a000e7a0:	ca000005 	bgt	a000e7bc <_Timespec_Less_than+0x30>           <== NOT EXECUTED
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/timespec.h>                                     
#include <rtems/score/tod.h>                                          
                                                                      
bool _Timespec_Less_than(                                             
a000e7a4:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
a000e7a8:	e5913004 	ldr	r3, [r1, #4]                                  <== NOT EXECUTED
a000e7ac:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000e7b0:	a3a00000 	movge	r0, #0                                      <== NOT EXECUTED
a000e7b4:	b3a00001 	movlt	r0, #1                                      <== NOT EXECUTED
a000e7b8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
{                                                                     
  if ( lhs->tv_sec < rhs->tv_sec )                                    
    return true;                                                      
                                                                      
  if ( lhs->tv_sec > rhs->tv_sec )                                    
    return false;                                                     
a000e7bc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */                            
  if ( lhs->tv_nsec < rhs->tv_nsec )                                  
    return true;                                                      
                                                                      
  return false;                                                       
}                                                                     
a000e7c0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000caac <_Timespec_Subtract>: const struct timespec *end, struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) {
a000caac:	e591c004 	ldr	ip, [r1, #4]                                  <== NOT EXECUTED
a000cab0:	e5903004 	ldr	r3, [r0, #4]                                  <== NOT EXECUTED
void _Timespec_Subtract(                                              
  const struct timespec *start,                                       
  const struct timespec *end,                                         
  struct timespec       *result                                       
)                                                                     
{                                                                     
a000cab4:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  if (end->tv_nsec < start->tv_nsec) {                                
a000cab8:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
a000cabc:	ba000007 	blt	a000cae0 <_Timespec_Subtract+0x34>            <== NOT EXECUTED
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
    result->tv_nsec =                                                 
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;   
  } else {                                                            
    result->tv_sec  = end->tv_sec - start->tv_sec;                    
a000cac0:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
a000cac4:	e5901000 	ldr	r1, [r0]                                      <== NOT EXECUTED
    result->tv_nsec = end->tv_nsec - start->tv_nsec;                  
a000cac8:	e063300c 	rsb	r3, r3, ip                                    <== NOT EXECUTED
a000cacc:	e5823004 	str	r3, [r2, #4]                                  <== NOT EXECUTED
  if (end->tv_nsec < start->tv_nsec) {                                
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
    result->tv_nsec =                                                 
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;   
  } else {                                                            
    result->tv_sec  = end->tv_sec - start->tv_sec;                    
a000cad0:	e0613004 	rsb	r3, r1, r4                                    <== NOT EXECUTED
a000cad4:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    result->tv_nsec = end->tv_nsec - start->tv_nsec;                  
  }                                                                   
}                                                                     
a000cad8:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a000cadc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  struct timespec       *result                                       
)                                                                     
{                                                                     
                                                                      
  if (end->tv_nsec < start->tv_nsec) {                                
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
a000cae0:	e5911000 	ldr	r1, [r1]                                      <== NOT EXECUTED
a000cae4:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
    result->tv_nsec =                                                 
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;   
a000cae8:	e28cc5ee 	add	ip, ip, #998244352	; 0x3b800000               <== NOT EXECUTED
a000caec:	e28cc96b 	add	ip, ip, #1753088	; 0x1ac000                   <== NOT EXECUTED
  struct timespec       *result                                       
)                                                                     
{                                                                     
                                                                      
  if (end->tv_nsec < start->tv_nsec) {                                
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
a000caf0:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
    result->tv_nsec =                                                 
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;   
a000caf4:	e28ccc0a 	add	ip, ip, #2560	; 0xa00                         <== NOT EXECUTED
  struct timespec       *result                                       
)                                                                     
{                                                                     
                                                                      
  if (end->tv_nsec < start->tv_nsec) {                                
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
a000caf8:	e0601001 	rsb	r1, r0, r1                                    <== NOT EXECUTED
    result->tv_nsec =                                                 
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;   
a000cafc:	e063300c 	rsb	r3, r3, ip                                    <== NOT EXECUTED
  struct timespec       *result                                       
)                                                                     
{                                                                     
                                                                      
  if (end->tv_nsec < start->tv_nsec) {                                
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;                
a000cb00:	e882000a 	stm	r2, {r1, r3}                                  <== NOT EXECUTED
a000cb04:	eafffff3 	b	a000cad8 <_Timespec_Subtract+0x2c>              <== NOT EXECUTED
                                                                      

a0021a10 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) {
a0021a10:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  uint32_t  ticks;                                                    
                                                                      
  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )                  
a0021a14:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
 */                                                                   
                                                                      
uint32_t _Timespec_To_ticks(                                          
  const struct timespec *time                                         
)                                                                     
{                                                                     
a0021a18:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  uint32_t  ticks;                                                    
                                                                      
  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )                  
a0021a1c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0021a20:	1a000002 	bne	a0021a30 <_Timespec_To_ticks+0x20>            <== NOT EXECUTED
a0021a24:	e5900004 	ldr	r0, [r0, #4]                                  <== NOT EXECUTED
a0021a28:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0021a2c:	0a000009 	beq	a0021a58 <_Timespec_To_ticks+0x48>            <== NOT EXECUTED
    return 0;                                                         
                                                                      
  ticks  = time->tv_sec * TOD_TICKS_PER_SECOND;                       
a0021a30:	eb000086 	bl	a0021c50 <TOD_TICKS_PER_SECOND_method>         <== NOT EXECUTED
                                                                      
  ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
a0021a34:	e59f3020 	ldr	r3, [pc, #32]	; a0021a5c <_Timespec_To_ticks+0x4c><== NOT EXECUTED
a0021a38:	e3a01ffa 	mov	r1, #1000	; 0x3e8                             <== NOT EXECUTED
  uint32_t  ticks;                                                    
                                                                      
  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )                  
    return 0;                                                         
                                                                      
  ticks  = time->tv_sec * TOD_TICKS_PER_SECOND;                       
a0021a3c:	e0040490 	mul	r4, r0, r4                                    <== NOT EXECUTED
                                                                      
  ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
a0021a40:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a0021a44:	e5950004 	ldr	r0, [r5, #4]                                  <== NOT EXECUTED
a0021a48:	e0010193 	mul	r1, r3, r1                                    <== NOT EXECUTED
a0021a4c:	ebfff68a 	bl	a001f47c <__aeabi_uidiv>                       <== NOT EXECUTED
                                                                      
  if (ticks)                                                          
a0021a50:	e0940000 	adds	r0, r4, r0                                   <== NOT EXECUTED
    return ticks;                                                     
                                                                      
  return 1;                                                           
a0021a54:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
}                                                                     
a0021a58:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000e39c <_User_extensions_Remove_set>: #include <rtems/score/userext.h> void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) {
a000e39c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000e3a0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  _Chain_Extract( &the_extension->Node );                             
a000e3a4:	ebfff608 	bl	a000bbcc <_Chain_Extract>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If a switch handler is present, remove it.                       
   */                                                                 
                                                                      
  if ( the_extension->Callouts.thread_switch != NULL )                
a000e3a8:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
a000e3ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000e3b0:	0a000002 	beq	a000e3c0 <_User_extensions_Remove_set+0x24>   <== NOT EXECUTED
    _Chain_Extract( &the_extension->Switch.Node );                    
a000e3b4:	e2840008 	add	r0, r4, #8                                    <== NOT EXECUTED
}                                                                     
a000e3b8:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
  /*                                                                  
   * If a switch handler is present, remove it.                       
   */                                                                 
                                                                      
  if ( the_extension->Callouts.thread_switch != NULL )                
    _Chain_Extract( &the_extension->Switch.Node );                    
a000e3bc:	eafff602 	b	a000bbcc <_Chain_Extract>                       <== NOT EXECUTED
a000e3c0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000cbb0 <_User_extensions_Thread_begin>: #include <rtems/score/userext.h> void _User_extensions_Thread_begin ( Thread_Control *executing ) {
a000cbb0:	e92d4070 	push	{r4, r5, r6, lr}                             
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
a000cbb4:	e59f5030 	ldr	r5, [pc, #48]	; a000cbec <_User_extensions_Thread_begin+0x3c>
#include <rtems/score/userext.h>                                      
                                                                      
void _User_extensions_Thread_begin (                                  
  Thread_Control *executing                                           
)                                                                     
{                                                                     
a000cbb8:	e1a06000 	mov	r6, r0                                        
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
a000cbbc:	e4954004 	ldr	r4, [r5], #4                                  
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000cbc0:	e1540005 	cmp	r4, r5                                        
a000cbc4:	0a000007 	beq	a000cbe8 <_User_extensions_Thread_begin+0x38> 
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_begin != NULL )               
a000cbc8:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          
      (*the_extension->Callouts.thread_begin)( executing );           
a000cbcc:	e1a00006 	mov	r0, r6                                        
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_begin != NULL )               
a000cbd0:	e3530000 	cmp	r3, #0                                        
a000cbd4:	0a000000 	beq	a000cbdc <_User_extensions_Thread_begin+0x2c> 
      (*the_extension->Callouts.thread_begin)( executing );           
a000cbd8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
a000cbdc:	e5944000 	ldr	r4, [r4]                                      
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000cbe0:	e1540005 	cmp	r4, r5                                        
a000cbe4:	1afffff7 	bne	a000cbc8 <_User_extensions_Thread_begin+0x18> 
a000cbe8:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

a000cc80 <_User_extensions_Thread_create>: #include <rtems/score/userext.h> bool _User_extensions_Thread_create ( Thread_Control *the_thread ) {
a000cc80:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
a000cc84:	e59f504c 	ldr	r5, [pc, #76]	; a000ccd8 <_User_extensions_Thread_create+0x58>
#include <rtems/score/userext.h>                                      
                                                                      
bool _User_extensions_Thread_create (                                 
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a000cc88:	e1a06000 	mov	r6, r0                                        
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
}                                                                     
a000cc8c:	e4954004 	ldr	r4, [r5], #4                                  
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000cc90:	e1540005 	cmp	r4, r5                                        
a000cc94:	0a00000d 	beq	a000ccd0 <_User_extensions_Thread_create+0x50>
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_create != NULL ) {            
      status = (*the_extension->Callouts.thread_create)(              
a000cc98:	e59f703c 	ldr	r7, [pc, #60]	; a000ccdc <_User_extensions_Thread_create+0x5c>
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_create != NULL ) {            
a000cc9c:	e5943014 	ldr	r3, [r4, #20]                                 
      status = (*the_extension->Callouts.thread_create)(              
a000cca0:	e1a01006 	mov	r1, r6                                        
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_create != NULL ) {            
a000cca4:	e3530000 	cmp	r3, #0                                        
a000cca8:	0a000003 	beq	a000ccbc <_User_extensions_Thread_create+0x3c>
      status = (*the_extension->Callouts.thread_create)(              
a000ccac:	e5970004 	ldr	r0, [r7, #4]                                  
a000ccb0:	e12fff33 	blx	r3                                            
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
      if ( !status )                                                  
a000ccb4:	e3500000 	cmp	r0, #0                                        
a000ccb8:	0a000005 	beq	a000ccd4 <_User_extensions_Thread_create+0x54>
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
a000ccbc:	e5944000 	ldr	r4, [r4]                                      
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
  bool                     status;                                    
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000ccc0:	e1540005 	cmp	r4, r5                                        
a000ccc4:	1afffff4 	bne	a000cc9c <_User_extensions_Thread_create+0x1c>
      if ( !status )                                                  
        return false;                                                 
    }                                                                 
  }                                                                   
                                                                      
  return true;                                                        
a000ccc8:	e3a00001 	mov	r0, #1                                        
a000cccc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
a000ccd0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
}                                                                     
a000ccd4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000cce0 <_User_extensions_Thread_delete>: #include <rtems/score/userext.h> void _User_extensions_Thread_delete ( Thread_Control *the_thread ) {
a000cce0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(                       
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
a000cce4:	e59f5038 	ldr	r5, [pc, #56]	; a000cd24 <_User_extensions_Thread_delete+0x44><== NOT EXECUTED
#include <rtems/score/userext.h>                                      
                                                                      
void _User_extensions_Thread_delete (                                 
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a000cce8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(                       
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
a000ccec:	e5954008 	ldr	r4, [r5, #8]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
a000ccf0:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000ccf4:	0a000009 	beq	a000cd20 <_User_extensions_Thread_delete+0x40><== NOT EXECUTED
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_delete != NULL )              
      (*the_extension->Callouts.thread_delete)(                       
a000ccf8:	e59f7028 	ldr	r7, [pc, #40]	; a000cd28 <_User_extensions_Thread_delete+0x48><== NOT EXECUTED
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_delete != NULL )              
a000ccfc:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(                       
a000cd00:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_delete != NULL )              
a000cd04:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000cd08:	0a000001 	beq	a000cd14 <_User_extensions_Thread_delete+0x34><== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(                       
a000cd0c:	e5970004 	ldr	r0, [r7, #4]                                  <== NOT EXECUTED
a000cd10:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
a000cd14:	e5944004 	ldr	r4, [r4, #4]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
a000cd18:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000cd1c:	1afffff6 	bne	a000ccfc <_User_extensions_Thread_delete+0x1c><== NOT EXECUTED
a000cd20:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000cbf0 <_User_extensions_Thread_exitted>: } void _User_extensions_Thread_exitted ( Thread_Control *executing ) {
a000cbf0:	e92d4070 	push	{r4, r5, r6, lr}                             
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
a000cbf4:	e59f5030 	ldr	r5, [pc, #48]	; a000cc2c <_User_extensions_Thread_exitted+0x3c>
}                                                                     
                                                                      
void _User_extensions_Thread_exitted (                                
  Thread_Control *executing                                           
)                                                                     
{                                                                     
a000cbf8:	e1a06000 	mov	r6, r0                                        
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.fatal != NULL )                      
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
  }                                                                   
}                                                                     
a000cbfc:	e5954008 	ldr	r4, [r5, #8]                                  
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
a000cc00:	e1540005 	cmp	r4, r5                                        
a000cc04:	0a000007 	beq	a000cc28 <_User_extensions_Thread_exitted+0x38>
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_exitted != NULL )             
a000cc08:	e594302c 	ldr	r3, [r4, #44]	; 0x2c                          
      (*the_extension->Callouts.thread_exitted)( executing );         
a000cc0c:	e1a00006 	mov	r0, r6                                        
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_exitted != NULL )             
a000cc10:	e3530000 	cmp	r3, #0                                        
a000cc14:	0a000000 	beq	a000cc1c <_User_extensions_Thread_exitted+0x2c>
      (*the_extension->Callouts.thread_exitted)( executing );         
a000cc18:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;         
        the_node = the_node->previous ) {                             
a000cc1c:	e5944004 	ldr	r4, [r4, #4]                                  
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_Last( &_User_extensions_List );             
a000cc20:	e1540005 	cmp	r4, r5                                        
a000cc24:	1afffff7 	bne	a000cc08 <_User_extensions_Thread_exitted+0x18>
a000cc28:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

a000dab8 <_User_extensions_Thread_restart>: #include <rtems/score/userext.h> void _User_extensions_Thread_restart ( Thread_Control *the_thread ) {
a000dab8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(                      
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
a000dabc:	e59f5038 	ldr	r5, [pc, #56]	; a000dafc <_User_extensions_Thread_restart+0x44><== NOT EXECUTED
#include <rtems/score/userext.h>                                      
                                                                      
void _User_extensions_Thread_restart (                                
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
a000dac0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(                      
        _Thread_Executing,                                            
        the_thread                                                    
      );                                                              
  }                                                                   
}                                                                     
a000dac4:	e4954004 	ldr	r4, [r5], #4                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000dac8:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000dacc:	0a000009 	beq	a000daf8 <_User_extensions_Thread_restart+0x40><== NOT EXECUTED
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_restart != NULL )             
      (*the_extension->Callouts.thread_restart)(                      
a000dad0:	e59f7028 	ldr	r7, [pc, #40]	; a000db00 <_User_extensions_Thread_restart+0x48><== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_restart != NULL )             
a000dad4:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(                      
a000dad8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
                                                                      
    the_extension = (User_extensions_Control *) the_node;             
                                                                      
    if ( the_extension->Callouts.thread_restart != NULL )             
a000dadc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000dae0:	0a000001 	beq	a000daec <_User_extensions_Thread_restart+0x34><== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(                      
a000dae4:	e5970004 	ldr	r0, [r7, #4]                                  <== NOT EXECUTED
a000dae8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;         
        the_node = the_node->next ) {                                 
a000daec:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node              *the_node;                                  
  User_extensions_Control *the_extension;                             
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_List );            
a000daf0:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000daf4:	1afffff6 	bne	a000dad4 <_User_extensions_Thread_restart+0x1c><== NOT EXECUTED
a000daf8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000cd78 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) {
a000cd78:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
                                                                      
    the_extension_switch = (User_extensions_Switch_control *) the_node;
                                                                      
    (*the_extension_switch->thread_switch)( executing, heir );        
  }                                                                   
}                                                                     
a000cd7c:	e59f5030 	ldr	r5, [pc, #48]	; a000cdb4 <_User_extensions_Thread_switch+0x3c><== NOT EXECUTED
                                                                      
void _User_extensions_Thread_switch (                                 
  Thread_Control *executing,                                          
  Thread_Control *heir                                                
)                                                                     
{                                                                     
a000cd80:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a000cd84:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
                                                                      
    the_extension_switch = (User_extensions_Switch_control *) the_node;
                                                                      
    (*the_extension_switch->thread_switch)( executing, heir );        
  }                                                                   
}                                                                     
a000cd88:	e4954004 	ldr	r4, [r5], #4                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
a000cd8c:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000cd90:	0a000006 	beq	a000cdb0 <_User_extensions_Thread_switch+0x38><== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
        the_node = the_node->next ) {                                 
                                                                      
    the_extension_switch = (User_extensions_Switch_control *) the_node;
                                                                      
    (*the_extension_switch->thread_switch)( executing, heir );        
a000cd94:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a000cd98:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000cd9c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000cda0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
        the_node = the_node->next ) {                                 
a000cda4:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node                     *the_node;                           
  User_extensions_Switch_control *the_extension_switch;               
                                                                      
  for ( the_node = _Chain_First( &_User_extensions_Switches_list );   
a000cda8:	e1540005 	cmp	r4, r5                                        <== NOT EXECUTED
a000cdac:	1afffff8 	bne	a000cd94 <_User_extensions_Thread_switch+0x1c><== NOT EXECUTED
a000cdb0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000ea74 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
a000ea74:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a000ea78:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000ea7c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000ea80:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a000ea84:	e3803080 	orr	r3, r0, #128	; 0x80                           <== NOT EXECUTED
a000ea88:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
a000ea8c:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
a000ea90:	e4973004 	ldr	r3, [r7], #4                                  <== NOT EXECUTED
   *       hence the compiler must not assume *header to remain       
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
a000ea94:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
a000ea98:	0a00001a 	beq	a000eb08 <_Watchdog_Adjust+0x94>              <== NOT EXECUTED
    switch ( direction ) {                                            
a000ea9c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000eaa0:	1a00001a 	bne	a000eb10 <_Watchdog_Adjust+0x9c>              <== NOT EXECUTED
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
a000eaa4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000eaa8:	0a000016 	beq	a000eb08 <_Watchdog_Adjust+0x94>              <== NOT EXECUTED
          if ( units < _Watchdog_First( header )->delta_interval ) {  
a000eaac:	e5936010 	ldr	r6, [r3, #16]                                 <== NOT EXECUTED
a000eab0:	e1520006 	cmp	r2, r6                                        <== NOT EXECUTED
a000eab4:	21a01000 	movcs	r1, r0                                      <== NOT EXECUTED
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
a000eab8:	23a08001 	movcs	r8, #1                                      <== NOT EXECUTED
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
a000eabc:	2a000005 	bcs	a000ead8 <_Watchdog_Adjust+0x64>              <== NOT EXECUTED
a000eac0:	ea000019 	b	a000eb2c <_Watchdog_Adjust+0xb8>                <== NOT EXECUTED
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
a000eac4:	e0555006 	subs	r5, r5, r6                                   <== NOT EXECUTED
a000eac8:	0a00000e 	beq	a000eb08 <_Watchdog_Adjust+0x94>              <== NOT EXECUTED
          if ( units < _Watchdog_First( header )->delta_interval ) {  
a000eacc:	e5936010 	ldr	r6, [r3, #16]                                 <== NOT EXECUTED
a000ead0:	e1560005 	cmp	r6, r5                                        <== NOT EXECUTED
a000ead4:	8a000014 	bhi	a000eb2c <_Watchdog_Adjust+0xb8>              <== NOT EXECUTED
            _Watchdog_First( header )->delta_interval -= units;       
            break;                                                    
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
            _Watchdog_First( header )->delta_interval = 1;            
a000ead8:	e5838010 	str	r8, [r3, #16]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000eadc:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
                                                                      
            _ISR_Enable( level );                                     
                                                                      
            _Watchdog_Tickle( header );                               
a000eae0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000eae4:	eb0000ad 	bl	a000eda0 <_Watchdog_Tickle>                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000eae8:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a000eaec:	e3803080 	orr	r3, r0, #128	; 0x80                           <== NOT EXECUTED
a000eaf0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
a000eaf4:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
a000eaf8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
                                                                      
            _Watchdog_Tickle( header );                               
                                                                      
            _ISR_Disable( level );                                    
                                                                      
            if ( _Chain_Is_empty( header ) )                          
a000eafc:	e1570002 	cmp	r7, r2                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(               
  Chain_Control *header                                               
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) _Chain_First( header ) );             
a000eb00:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
a000eb04:	1affffee 	bne	a000eac4 <_Watchdog_Adjust+0x50>              <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000eb08:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
a000eb0c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
    switch ( direction ) {                                            
a000eb10:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
a000eb14:	1afffffb 	bne	a000eb08 <_Watchdog_Adjust+0x94>              <== NOT EXECUTED
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
a000eb18:	e5932010 	ldr	r2, [r3, #16]                                 <== NOT EXECUTED
a000eb1c:	e0825005 	add	r5, r2, r5                                    <== NOT EXECUTED
a000eb20:	e5835010 	str	r5, [r3, #16]                                 <== NOT EXECUTED
a000eb24:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
                                                                      
}                                                                     
a000eb28:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
            _Watchdog_First( header )->delta_interval -= units;       
a000eb2c:	e0655006 	rsb	r5, r5, r6                                    <== NOT EXECUTED
a000eb30:	e5835010 	str	r5, [r3, #16]                                 <== NOT EXECUTED
            break;                                                    
a000eb34:	eafffff3 	b	a000eb08 <_Watchdog_Adjust+0x94>                <== NOT EXECUTED
                                                                      

a001e95c <_Watchdog_Adjust_to_chain>: { Watchdog_Interval units = units_arg; ISR_Level level; Watchdog_Control *first; if ( units <= 0 ) {
a001e95c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
  Chain_Control               *header,                                
  Watchdog_Interval            units_arg,                             
  Chain_Control               *to_fire                                
                                                                      
)                                                                     
{                                                                     
a001e960:	e92d05f0 	push	{r4, r5, r6, r7, r8, sl}                     <== NOT EXECUTED
  Watchdog_Interval  units = units_arg;                               
  ISR_Level          level;                                           
  Watchdog_Control  *first;                                           
                                                                      
  if ( units <= 0 ) {                                                 
a001e964:	0a000022 	beq	a001e9f4 <_Watchdog_Adjust_to_chain+0x98>     <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001e968:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
a001e96c:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
a001e970:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  _ISR_Disable( level );                                              
a001e974:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a001e978:	e4963004 	ldr	r3, [r6], #4                                  <== NOT EXECUTED
    /*                                                                
     *  The first set happens in less than units, so take all of them 
     *  off the chain and adjust units to reflect this.               
     */                                                               
    units -= first->delta_interval;                                   
    first->delta_interval = 0;                                        
a001e97c:	e3a0a000 	mov	sl, #0                                        <== NOT EXECUTED
a001e980:	e2828004 	add	r8, r2, #4                                    <== NOT EXECUTED
                                                                      
  while ( 1 ) {                                                       
    if ( units <= 0 ) {                                               
      break;                                                          
    }                                                                 
    if ( _Chain_Is_empty( header ) ) {                                
a001e984:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a001e988:	0a000018 	beq	a001e9f0 <_Watchdog_Adjust_to_chain+0x94>     <== NOT EXECUTED
                                                                      
    /*                                                                
     *  If it is longer than "units" until the first element on the chain
     *  fires, then bump it and quit.                                 
     */                                                               
    if ( units < first->delta_interval ) {                            
a001e98c:	e593c010 	ldr	ip, [r3, #16]                                 <== NOT EXECUTED
a001e990:	e15c0001 	cmp	ip, r1                                        <== NOT EXECUTED
a001e994:	8a000018 	bhi	a001e9fc <_Watchdog_Adjust_to_chain+0xa0>     <== NOT EXECUTED
                                                                      
    /*                                                                
     *  The first set happens in less than units, so take all of them 
     *  off the chain and adjust units to reflect this.               
     */                                                               
    units -= first->delta_interval;                                   
a001e998:	e06c1001 	rsb	r1, ip, r1                                    <== NOT EXECUTED
    first->delta_interval = 0;                                        
a001e99c:	e583a010 	str	sl, [r3, #16]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
a001e9a0:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
  previous       = the_node->previous;                                
a001e9a4:	e5934004 	ldr	r4, [r3, #4]                                  <== NOT EXECUTED
  next->previous = previous;                                          
a001e9a8:	e5854004 	str	r4, [r5, #4]                                  <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
a001e9ac:	e592c008 	ldr	ip, [r2, #8]                                  <== NOT EXECUTED
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
  previous->next = next;                                              
a001e9b0:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
a001e9b4:	e5838000 	str	r8, [r3]                                      <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
a001e9b8:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
a001e9bc:	e5823008 	str	r3, [r2, #8]                                  <== NOT EXECUTED
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
a001e9c0:	e583c004 	str	ip, [r3, #4]                                  <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a001e9c4:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a001e9c8:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
a001e9cc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
}                                                                     
a001e9d0:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
      _Chain_Extract_unprotected( &first->Node );                     
      _Chain_Append_unprotected( to_fire, &first->Node );             
                                                                      
      _ISR_Flash( level );                                            
                                                                      
      if ( _Chain_Is_empty( header ) )                                
a001e9d4:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
a001e9d8:	0a000002 	beq	a001e9e8 <_Watchdog_Adjust_to_chain+0x8c>     <== NOT EXECUTED
        break;                                                        
      first = _Watchdog_First( header );                              
      if ( first->delta_interval != 0 )                               
a001e9dc:	e593c010 	ldr	ip, [r3, #16]                                 <== NOT EXECUTED
a001e9e0:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a001e9e4:	0affffed 	beq	a001e9a0 <_Watchdog_Adjust_to_chain+0x44>     <== NOT EXECUTED
  }                                                                   
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  while ( 1 ) {                                                       
    if ( units <= 0 ) {                                               
a001e9e8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a001e9ec:	1affffe4 	bne	a001e984 <_Watchdog_Adjust_to_chain+0x28>     <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001e9f0:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
}                                                                     
a001e9f4:	e8bd05f0 	pop	{r4, r5, r6, r7, r8, sl}                      <== NOT EXECUTED
a001e9f8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    /*                                                                
     *  If it is longer than "units" until the first element on the chain
     *  fires, then bump it and quit.                                 
     */                                                               
    if ( units < first->delta_interval ) {                            
      first->delta_interval -= units;                                 
a001e9fc:	e061100c 	rsb	r1, r1, ip                                    <== NOT EXECUTED
a001ea00:	e5831010 	str	r1, [r3, #16]                                 <== NOT EXECUTED
      break;                                                          
a001ea04:	eafffff9 	b	a001e9f0 <_Watchdog_Adjust_to_chain+0x94>       <== NOT EXECUTED
                                                                      

a000cdb8 <_Watchdog_Insert>: Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level;
a000cdb8:	e59f3140 	ldr	r3, [pc, #320]	; a000cf00 <_Watchdog_Insert+0x148><== NOT EXECUTED
                                                                      
void _Watchdog_Insert(                                                
  Chain_Control         *header,                                      
  Watchdog_Control      *the_watchdog                                 
)                                                                     
{                                                                     
a000cdbc:	e92d01f0 	push	{r4, r5, r6, r7, r8}                         <== NOT EXECUTED
  Watchdog_Control  *after;                                           
  uint32_t           insert_isr_nest_level;                           
  Watchdog_Interval  delta_interval;                                  
                                                                      
                                                                      
  insert_isr_nest_level   = _ISR_Nest_level;                          
a000cdc0:	e5936000 	ldr	r6, [r3]                                      <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000cdc4:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a000cdc8:	e3853080 	orr	r3, r5, #128	; 0x80                           <== NOT EXECUTED
a000cdcc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  /*                                                                  
   *  Check to see if the watchdog has just been inserted by a        
   *  higher priority interrupt.  If so, abandon this insert.         
   */                                                                 
                                                                      
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {                   
a000cdd0:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
a000cdd4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000cdd8:	1a000041 	bne	a000cee4 <_Watchdog_Insert+0x12c>             <== NOT EXECUTED
    _ISR_Enable( level );                                             
    return;                                                           
  }                                                                   
                                                                      
  the_watchdog->state = WATCHDOG_BEING_INSERTED;                      
  _Watchdog_Sync_count++;                                             
a000cddc:	e59f8120 	ldr	r8, [pc, #288]	; a000cf04 <_Watchdog_Insert+0x14c><== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {                   
    _ISR_Enable( level );                                             
    return;                                                           
  }                                                                   
                                                                      
  the_watchdog->state = WATCHDOG_BEING_INSERTED;                      
a000cde0:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000cde4:	e59f711c 	ldr	r7, [pc, #284]	; a000cf08 <_Watchdog_Insert+0x150><== NOT EXECUTED
  _Watchdog_Sync_count++;                                             
a000cde8:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {                   
    _ISR_Enable( level );                                             
    return;                                                           
  }                                                                   
                                                                      
  the_watchdog->state = WATCHDOG_BEING_INSERTED;                      
a000cdec:	e5812008 	str	r2, [r1, #8]                                  <== NOT EXECUTED
  _Watchdog_Sync_count++;                                             
a000cdf0:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
a000cdf4:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
                                                                      
restart:                                                              
  delta_interval = the_watchdog->initial;                             
a000cdf8:	e591300c 	ldr	r3, [r1, #12]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(               
  Chain_Control *header                                               
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) _Chain_First( header ) );             
a000cdfc:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
                                                                      
  for ( after = _Watchdog_First( header ) ;                           
        ;                                                             
        after = _Watchdog_Next( after ) ) {                           
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
a000ce00:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ce04:	0a000023 	beq	a000ce98 <_Watchdog_Insert+0xe0>              <== NOT EXECUTED
a000ce08:	e592c000 	ldr	ip, [r2]                                      <== NOT EXECUTED
a000ce0c:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000ce10:	0a000020 	beq	a000ce98 <_Watchdog_Insert+0xe0>              <== NOT EXECUTED
       break;                                                         
                                                                      
     if ( delta_interval < after->delta_interval ) {                  
a000ce14:	e592c010 	ldr	ip, [r2, #16]                                 <== NOT EXECUTED
a000ce18:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a000ce1c:	3a000032 	bcc	a000ceec <_Watchdog_Insert+0x134>             <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_flash( uint32_t level )              
{                                                                     
  uint32_t arm_switch_reg;                                            
                                                                      
  __asm__ volatile (                                                  
a000ce20:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000ce24:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
a000ce28:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
                                                                      
     delta_interval -= after->delta_interval;                         
                                                                      
     _ISR_Flash( level );                                             
                                                                      
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
a000ce2c:	e5914008 	ldr	r4, [r1, #8]                                  <== NOT EXECUTED
a000ce30:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
a000ce34:	1a000023 	bne	a000cec8 <_Watchdog_Insert+0x110>             <== NOT EXECUTED
       goto exit_insert;                                              
     }                                                                
                                                                      
     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {            
a000ce38:	e5974000 	ldr	r4, [r7]                                      <== NOT EXECUTED
a000ce3c:	e1560004 	cmp	r6, r4                                        <== NOT EXECUTED
     if ( delta_interval < after->delta_interval ) {                  
       after->delta_interval -= delta_interval;                       
       break;                                                         
     }                                                                
                                                                      
     delta_interval -= after->delta_interval;                         
a000ce40:	206c3003 	rsbcs	r3, ip, r3                                  <== NOT EXECUTED
                                                                      
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
       goto exit_insert;                                              
     }                                                                
                                                                      
     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {            
a000ce44:	2a000010 	bcs	a000ce8c <_Watchdog_Insert+0xd4>              <== NOT EXECUTED
a000ce48:	ea00002a 	b	a000cef8 <_Watchdog_Insert+0x140>               <== NOT EXECUTED
                                                                      
  for ( after = _Watchdog_First( header ) ;                           
        ;                                                             
        after = _Watchdog_Next( after ) ) {                           
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
a000ce4c:	e592c000 	ldr	ip, [r2]                                      <== NOT EXECUTED
a000ce50:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000ce54:	0a00000f 	beq	a000ce98 <_Watchdog_Insert+0xe0>              <== NOT EXECUTED
       break;                                                         
                                                                      
     if ( delta_interval < after->delta_interval ) {                  
a000ce58:	e592c010 	ldr	ip, [r2, #16]                                 <== NOT EXECUTED
a000ce5c:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
a000ce60:	8a000021 	bhi	a000ceec <_Watchdog_Insert+0x134>             <== NOT EXECUTED
a000ce64:	e10f4000 	mrs	r4, CPSR                                      <== NOT EXECUTED
a000ce68:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
a000ce6c:	e129f004 	msr	CPSR_fc, r4                                   <== NOT EXECUTED
                                                                      
     delta_interval -= after->delta_interval;                         
                                                                      
     _ISR_Flash( level );                                             
                                                                      
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
a000ce70:	e5914008 	ldr	r4, [r1, #8]                                  <== NOT EXECUTED
     if ( delta_interval < after->delta_interval ) {                  
       after->delta_interval -= delta_interval;                       
       break;                                                         
     }                                                                
                                                                      
     delta_interval -= after->delta_interval;                         
a000ce74:	e06c3003 	rsb	r3, ip, r3                                    <== NOT EXECUTED
                                                                      
     _ISR_Flash( level );                                             
                                                                      
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
a000ce78:	e3540001 	cmp	r4, #1                                        <== NOT EXECUTED
a000ce7c:	1a000011 	bne	a000cec8 <_Watchdog_Insert+0x110>             <== NOT EXECUTED
       goto exit_insert;                                              
     }                                                                
                                                                      
     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {            
a000ce80:	e597c000 	ldr	ip, [r7]                                      <== NOT EXECUTED
a000ce84:	e156000c 	cmp	r6, ip                                        <== NOT EXECUTED
a000ce88:	3a00001a 	bcc	a000cef8 <_Watchdog_Insert+0x140>             <== NOT EXECUTED
                                                                      
  for ( after = _Watchdog_First( header ) ;                           
        ;                                                             
        after = _Watchdog_Next( after ) ) {                           
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
a000ce8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
exit_insert:                                                          
  _Watchdog_Sync_level = insert_isr_nest_level;                       
  _Watchdog_Sync_count--;                                             
  _ISR_Enable( level );                                               
}                                                                     
a000ce90:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
                                                                      
  for ( after = _Watchdog_First( header ) ;                           
        ;                                                             
        after = _Watchdog_Next( after ) ) {                           
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
a000ce94:	1affffec 	bne	a000ce4c <_Watchdog_Insert+0x94>              <== NOT EXECUTED
                                                                      
  _Watchdog_Activate( the_watchdog );                                 
                                                                      
  the_watchdog->delta_interval = delta_interval;                      
                                                                      
  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
a000ce98:	e5922004 	ldr	r2, [r2, #4]                                  <== NOT EXECUTED
                                                                      
  the_watchdog->start_time = _Watchdog_Ticks_since_boot;              
a000ce9c:	e59fc068 	ldr	ip, [pc, #104]	; a000cf0c <_Watchdog_Insert+0x154><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(                         
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_ACTIVE;                              
a000cea0:	e3a04002 	mov	r4, #2                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
a000cea4:	e5920000 	ldr	r0, [r2]                                      <== NOT EXECUTED
a000cea8:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a000ceac:	e5814008 	str	r4, [r1, #8]                                  <== NOT EXECUTED
     }                                                                
  }                                                                   
                                                                      
  _Watchdog_Activate( the_watchdog );                                 
                                                                      
  the_watchdog->delta_interval = delta_interval;                      
a000ceb0:	e5813010 	str	r3, [r1, #16]                                 <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
a000ceb4:	e5812004 	str	r2, [r1, #4]                                  <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
a000ceb8:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
  the_node->next        = before_node;                                
  before_node->previous = the_node;                                   
a000cebc:	e5801004 	str	r1, [r0, #4]                                  <== NOT EXECUTED
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
a000cec0:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
                                                                      
  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
                                                                      
  the_watchdog->start_time = _Watchdog_Ticks_since_boot;              
a000cec4:	e581c014 	str	ip, [r1, #20]                                 <== NOT EXECUTED
                                                                      
exit_insert:                                                          
  _Watchdog_Sync_level = insert_isr_nest_level;                       
a000cec8:	e5876000 	str	r6, [r7]                                      <== NOT EXECUTED
  _Watchdog_Sync_count--;                                             
a000cecc:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
a000ced0:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000ced4:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000ced8:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
  _ISR_Enable( level );                                               
}                                                                     
a000cedc:	e8bd01f0 	pop	{r4, r5, r6, r7, r8}                          <== NOT EXECUTED
a000cee0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
a000cee4:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
a000cee8:	eafffffb 	b	a000cedc <_Watchdog_Insert+0x124>               <== NOT EXECUTED
                                                                      
     if ( delta_interval == 0 || !_Watchdog_Next( after ) )           
       break;                                                         
                                                                      
     if ( delta_interval < after->delta_interval ) {                  
       after->delta_interval -= delta_interval;                       
a000ceec:	e063c00c 	rsb	ip, r3, ip                                    <== NOT EXECUTED
a000cef0:	e582c010 	str	ip, [r2, #16]                                 <== NOT EXECUTED
       break;                                                         
a000cef4:	eaffffe7 	b	a000ce98 <_Watchdog_Insert+0xe0>                <== NOT EXECUTED
     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {          
       goto exit_insert;                                              
     }                                                                
                                                                      
     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {            
       _Watchdog_Sync_level = insert_isr_nest_level;                  
a000cef8:	e5876000 	str	r6, [r7]                                      <== NOT EXECUTED
       goto restart;                                                  
a000cefc:	eaffffbd 	b	a000cdf8 <_Watchdog_Insert+0x40>                <== NOT EXECUTED
                                                                      

a000cf74 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
a000cf74:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000cf78:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000cf7c:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000cf80:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
a000cf84:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
  switch ( previous_state ) {                                         
a000cf88:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                                      
      /*                                                              
       *  It is not actually on the chain so just change the state and
       *  the Insert operation we interrupted will be aborted.        
       */                                                             
      the_watchdog->state = WATCHDOG_INACTIVE;                        
a000cf8c:	03a01000 	moveq	r1, #0                                      <== NOT EXECUTED
a000cf90:	05801008 	streq	r1, [r0, #8]                                <== NOT EXECUTED
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
  switch ( previous_state ) {                                         
a000cf94:	0a000000 	beq	a000cf9c <_Watchdog_Remove+0x28>              <== NOT EXECUTED
a000cf98:	2a000006 	bcs	a000cfb8 <_Watchdog_Remove+0x44>              <== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;                       
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
a000cf9c:	e59f106c 	ldr	r1, [pc, #108]	; a000d010 <_Watchdog_Remove+0x9c><== NOT EXECUTED
a000cfa0:	e5911000 	ldr	r1, [r1]                                      <== NOT EXECUTED
a000cfa4:	e5801018 	str	r1, [r0, #24]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000cfa8:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
  _ISR_Enable( level );                                               
  return( previous_state );                                           
}                                                                     
a000cfac:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000cfb0:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a000cfb4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
  switch ( previous_state ) {                                         
a000cfb8:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a000cfbc:	8afffff6 	bhi	a000cf9c <_Watchdog_Remove+0x28>              <== NOT EXECUTED
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
                                                                      
  _ISR_Enable( level );                                               
  return( previous_state );                                           
}                                                                     
a000cfc0:	e5901000 	ldr	r1, [r0]                                      <== NOT EXECUTED
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
a000cfc4:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a000cfc8:	e580c008 	str	ip, [r0, #8]                                  <== NOT EXECUTED
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
a000cfcc:	e591c000 	ldr	ip, [r1]                                      <== NOT EXECUTED
a000cfd0:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
        next_watchdog->delta_interval += the_watchdog->delta_interval;
a000cfd4:	15914010 	ldrne	r4, [r1, #16]                               <== NOT EXECUTED
a000cfd8:	1590c010 	ldrne	ip, [r0, #16]                               <== NOT EXECUTED
a000cfdc:	1084c00c 	addne	ip, r4, ip                                  <== NOT EXECUTED
a000cfe0:	1581c010 	strne	ip, [r1, #16]                               <== NOT EXECUTED
                                                                      
      if ( _Watchdog_Sync_count )                                     
a000cfe4:	e59fc028 	ldr	ip, [pc, #40]	; a000d014 <_Watchdog_Remove+0xa0><== NOT EXECUTED
a000cfe8:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a000cfec:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;                       
a000cff0:	159fc020 	ldrne	ip, [pc, #32]	; a000d018 <_Watchdog_Remove+0xa4><== NOT EXECUTED
a000cff4:	159c4000 	ldrne	r4, [ip]                                    <== NOT EXECUTED
a000cff8:	159fc01c 	ldrne	ip, [pc, #28]	; a000d01c <_Watchdog_Remove+0xa8><== NOT EXECUTED
a000cffc:	158c4000 	strne	r4, [ip]                                    <== NOT EXECUTED
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
a000d000:	e590c004 	ldr	ip, [r0, #4]                                  <== NOT EXECUTED
  next->previous = previous;                                          
a000d004:	e581c004 	str	ip, [r1, #4]                                  <== NOT EXECUTED
  previous->next = next;                                              
a000d008:	e58c1000 	str	r1, [ip]                                      <== NOT EXECUTED
a000d00c:	eaffffe2 	b	a000cf9c <_Watchdog_Remove+0x28>                <== NOT EXECUTED
                                                                      

a000e540 <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) {
a000e540:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  printk(                                                             
a000e544:	e591e00c 	ldr	lr, [r1, #12]                                 <== NOT EXECUTED
                                                                      
void _Watchdog_Report(                                                
  const char        *name,                                            
  Watchdog_Control  *watch                                            
)                                                                     
{                                                                     
a000e548:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
  printk(                                                             
a000e54c:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
a000e550:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
a000e554:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
a000e558:	e591e01c 	ldr	lr, [r1, #28]                                 <== NOT EXECUTED
a000e55c:	e250c000 	subs	ip, r0, #0                                   <== NOT EXECUTED
a000e560:	059fc02c 	ldreq	ip, [pc, #44]	; a000e594 <_Watchdog_Report+0x54><== NOT EXECUTED
a000e564:	e58de008 	str	lr, [sp, #8]                                  <== NOT EXECUTED
a000e568:	e591e020 	ldr	lr, [r1, #32]                                 <== NOT EXECUTED
a000e56c:	01a0200c 	moveq	r2, ip                                      <== NOT EXECUTED
a000e570:	159f2020 	ldrne	r2, [pc, #32]	; a000e598 <_Watchdog_Report+0x58><== NOT EXECUTED
a000e574:	e58de00c 	str	lr, [sp, #12]                                 <== NOT EXECUTED
a000e578:	e5911024 	ldr	r1, [r1, #36]	; 0x24                          <== NOT EXECUTED
a000e57c:	e59f0018 	ldr	r0, [pc, #24]	; a000e59c <_Watchdog_Report+0x5c><== NOT EXECUTED
a000e580:	e58d1010 	str	r1, [sp, #16]                                 <== NOT EXECUTED
a000e584:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
a000e588:	ebffe680 	bl	a0007f90 <printk>                              <== NOT EXECUTED
    watch,                                                            
    watch->routine,                                                   
    watch->id,                                                        
    watch->user_data                                                  
  );                                                                  
}                                                                     
a000e58c:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a000e590:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000e4c8 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) {
a000e4c8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a000e4cc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000e4d0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000e4d4:	e10f6000 	mrs	r6, CPSR                                      <== NOT EXECUTED
a000e4d8:	e3863080 	orr	r3, r6, #128	; 0x80                           <== NOT EXECUTED
a000e4dc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
a000e4e0:	e59f004c 	ldr	r0, [pc, #76]	; a000e534 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED
a000e4e4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000e4e8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000e4ec:	ebffe6a7 	bl	a0007f90 <printk>                              <== NOT EXECUTED
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
}                                                                     
a000e4f0:	e4947004 	ldr	r7, [r4], #4                                  <== NOT EXECUTED
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
a000e4f4:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
a000e4f8:	0a00000a 	beq	a000e528 <_Watchdog_Report_chain+0x60>        <== NOT EXECUTED
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
a000e4fc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000e500:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000e504:	eb00000d 	bl	a000e540 <_Watchdog_Report>                    <== NOT EXECUTED
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
a000e508:	e5977000 	ldr	r7, [r7]                                      <== NOT EXECUTED
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
    printk( "Watchdog Chain: %s %p\n", name, header );                
    if ( !_Chain_Is_empty( header ) ) {                               
      for ( node = _Chain_First( header ) ;                           
a000e50c:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
a000e510:	1afffff9 	bne	a000e4fc <_Watchdog_Report_chain+0x34>        <== NOT EXECUTED
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
a000e514:	e59f001c 	ldr	r0, [pc, #28]	; a000e538 <_Watchdog_Report_chain+0x70><== NOT EXECUTED
a000e518:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000e51c:	ebffe69b 	bl	a0007f90 <printk>                              <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000e520:	e129f006 	msr	CPSR_fc, r6                                   <== NOT EXECUTED
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
}                                                                     
a000e524:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
a000e528:	e59f000c 	ldr	r0, [pc, #12]	; a000e53c <_Watchdog_Report_chain+0x74><== NOT EXECUTED
a000e52c:	ebffe697 	bl	a0007f90 <printk>                              <== NOT EXECUTED
a000e530:	eafffffa 	b	a000e520 <_Watchdog_Report_chain+0x58>          <== NOT EXECUTED
                                                                      

a000d020 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) {
a000d020:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a000d024:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000d028:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
a000d02c:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
a000d030:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
}                                                                     
a000d034:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000d038:	e4943004 	ldr	r3, [r4], #4                                  <== NOT EXECUTED
   * volatile data - till, 2003/7                                     
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  if ( _Chain_Is_empty( header ) )                                    
a000d03c:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000d040:	0a000007 	beq	a000d064 <_Watchdog_Tickle+0x44>              <== NOT EXECUTED
   * to be inserted has already had its delta_interval adjusted to 0, and
   * so is added to the head of the chain with a delta_interval of 0. 
   *                                                                  
   * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)              
   */                                                                 
  if (the_watchdog->delta_interval != 0) {                            
a000d044:	e5931010 	ldr	r1, [r3, #16]                                 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(               
  Chain_Control *header                                               
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) _Chain_First( header ) );             
a000d048:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
a000d04c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000d050:	0a000015 	beq	a000d0ac <_Watchdog_Tickle+0x8c>              <== NOT EXECUTED
    the_watchdog->delta_interval--;                                   
a000d054:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )                          
a000d058:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
   * so is added to the head of the chain with a delta_interval of 0. 
   *                                                                  
   * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)              
   */                                                                 
  if (the_watchdog->delta_interval != 0) {                            
    the_watchdog->delta_interval--;                                   
a000d05c:	e5831010 	str	r1, [r3, #16]                                 <== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )                          
a000d060:	0a000011 	beq	a000d0ac <_Watchdog_Tickle+0x8c>              <== NOT EXECUTED
   * See the comment in watchdoginsert.c and watchdogadjust.c         
   * about why it's safe not to declare header a pointer to           
   * volatile data - till, 2003/7                                     
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
a000d064:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000d068:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
}                                                                     
a000d06c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
     _ISR_Enable( level );                                            
                                                                      
     switch( watchdog_state ) {                                       
       case WATCHDOG_ACTIVE:                                          
         (*the_watchdog->routine)(                                    
a000d070:	e596301c 	ldr	r3, [r6, #28]                                 <== NOT EXECUTED
a000d074:	e5960020 	ldr	r0, [r6, #32]                                 <== NOT EXECUTED
a000d078:	e5961024 	ldr	r1, [r6, #36]	; 0x24                          <== NOT EXECUTED
a000d07c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000d080:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000d084:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000d088:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
}                                                                     
a000d08c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000d090:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
                                                                      
     _ISR_Disable( level );                                           
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
a000d094:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000d098:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
a000d09c:	0afffff1 	beq	a000d068 <_Watchdog_Tickle+0x48>              <== NOT EXECUTED
     }                                                                
                                                                      
     _ISR_Disable( level );                                           
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
a000d0a0:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000d0a4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000d0a8:	1affffee 	bne	a000d068 <_Watchdog_Tickle+0x48>              <== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )                          
      goto leave;                                                     
  }                                                                   
                                                                      
  do {                                                                
     watchdog_state = _Watchdog_Remove( the_watchdog );               
a000d0ac:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000d0b0:	ebffffaf 	bl	a000cf74 <_Watchdog_Remove>                    <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000d0b4:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
                                                                      
     _ISR_Enable( level );                                            
                                                                      
     switch( watchdog_state ) {                                       
a000d0b8:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a000d0bc:	1affffef 	bne	a000d080 <_Watchdog_Tickle+0x60>              <== NOT EXECUTED
a000d0c0:	eaffffea 	b	a000d070 <_Watchdog_Tickle+0x50>                <== NOT EXECUTED
                                                                      

a000d150 <_Workspace_Allocate_or_fatal_error>:
a000d150:	e3a02000 	mov	r2, #0                                        
 *  _Workspace_Allocate_or_fatal_error                                
 */                                                                   
void *_Workspace_Allocate_or_fatal_error(                             
  size_t      size                                                    
)                                                                     
{                                                                     
a000d154:	e1a01000 	mov	r1, r0                                        
a000d158:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
a000d15c:	e59f0018 	ldr	r0, [pc, #24]	; a000d17c <_Workspace_Allocate_or_fatal_error+0x2c>
a000d160:	e1a03002 	mov	r3, r2                                        
a000d164:	eb000858 	bl	a000f2cc <_Heap_Allocate_aligned_with_boundary>
      __builtin_return_address( 1 ),                                  
      memory                                                          
    );                                                                
  #endif                                                              
                                                                      
  if ( memory == NULL )                                               
a000d168:	e3500000 	cmp	r0, #0                                        
a000d16c:	149df004 	popne	{pc}		; (ldrne pc, [sp], #4)                
    _Internal_error_Occurred(                                         
a000d170:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000d174:	e3a02003 	mov	r2, #3                                        <== NOT EXECUTED
a000d178:	ebfff6f6 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a000d0c4 <_Workspace_Handler_initialization>: * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start;
a000d0c4:	e59f3054 	ldr	r3, [pc, #84]	; a000d120 <_Workspace_Handler_initialization+0x5c>
                                                                      
/*                                                                    
 *  _Workspace_Handler_initialization                                 
 */                                                                   
void _Workspace_Handler_initialization(void)                          
{                                                                     
a000d0c8:	e92d4030 	push	{r4, r5, lr}                                 
  uintptr_t memory_available = 0;                                     
  void *starting_address = Configuration.work_space_start;            
  uintptr_t size = Configuration.work_space_size;                     
                                                                      
  if ( Configuration.do_zero_of_workspace )                           
a000d0cc:	e5d32028 	ldrb	r2, [r3, #40]	; 0x28                         
 *  _Workspace_Handler_initialization                                 
 */                                                                   
void _Workspace_Handler_initialization(void)                          
{                                                                     
  uintptr_t memory_available = 0;                                     
  void *starting_address = Configuration.work_space_start;            
a000d0d0:	e5935000 	ldr	r5, [r3]                                      
  uintptr_t size = Configuration.work_space_size;                     
a000d0d4:	e5934004 	ldr	r4, [r3, #4]                                  
                                                                      
  if ( Configuration.do_zero_of_workspace )                           
a000d0d8:	e3520000 	cmp	r2, #0                                        
a000d0dc:	1a000007 	bne	a000d100 <_Workspace_Handler_initialization+0x3c>
   memset( starting_address, 0, size );                               
                                                                      
  memory_available = _Heap_Initialize(                                
a000d0e0:	e59f003c 	ldr	r0, [pc, #60]	; a000d124 <_Workspace_Handler_initialization+0x60>
a000d0e4:	e1a01005 	mov	r1, r5                                        
a000d0e8:	e1a02004 	mov	r2, r4                                        
a000d0ec:	e3a03008 	mov	r3, #8                                        
a000d0f0:	ebfff67d 	bl	a000aaec <_Heap_Initialize>                    
    starting_address,                                                 
    size,                                                             
    CPU_HEAP_ALIGNMENT                                                
  );                                                                  
                                                                      
  if ( memory_available == 0 )                                        
a000d0f4:	e3500000 	cmp	r0, #0                                        
a000d0f8:	0a000005 	beq	a000d114 <_Workspace_Handler_initialization+0x50>
a000d0fc:	e8bd8030 	pop	{r4, r5, pc}                                  
  uintptr_t memory_available = 0;                                     
  void *starting_address = Configuration.work_space_start;            
  uintptr_t size = Configuration.work_space_size;                     
                                                                      
  if ( Configuration.do_zero_of_workspace )                           
   memset( starting_address, 0, size );                               
a000d100:	e1a00005 	mov	r0, r5                                        
a000d104:	e3a01000 	mov	r1, #0                                        
a000d108:	e1a02004 	mov	r2, r4                                        
a000d10c:	eb001258 	bl	a0011a74 <memset>                              
a000d110:	eafffff2 	b	a000d0e0 <_Workspace_Handler_initialization+0x1c>
    size,                                                             
    CPU_HEAP_ALIGNMENT                                                
  );                                                                  
                                                                      
  if ( memory_available == 0 )                                        
    _Internal_error_Occurred(                                         
a000d114:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000d118:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a000d11c:	ebfff70d 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a00096e0 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) {
a00096e0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",       
a00096e4:	e252e000 	subs	lr, r2, #0                                   <== NOT EXECUTED
  const char *file,                                                   
  int         line,                                                   
  const char *func,                                                   
  const char *failedexpr                                              
)                                                                     
{                                                                     
a00096e8:	e1a0c001 	mov	ip, r1                                        <== NOT EXECUTED
  printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",       
a00096ec:	059f102c 	ldreq	r1, [pc, #44]	; a0009720 <__assert_func+0x40><== NOT EXECUTED
a00096f0:	159f102c 	ldrne	r1, [pc, #44]	; a0009724 <__assert_func+0x44><== NOT EXECUTED
  const char *file,                                                   
  int         line,                                                   
  const char *func,                                                   
  const char *failedexpr                                              
)                                                                     
{                                                                     
a00096f4:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",       
a00096f8:	01a0e001 	moveq	lr, r1                                      <== NOT EXECUTED
  const char *file,                                                   
  int         line,                                                   
  const char *func,                                                   
  const char *failedexpr                                              
)                                                                     
{                                                                     
a00096fc:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
  printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",       
a0009700:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a0009704:	e59f001c 	ldr	r0, [pc, #28]	; a0009728 <__assert_func+0x48> <== NOT EXECUTED
a0009708:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a000970c:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a0009710:	e58de004 	str	lr, [sp, #4]                                  <== NOT EXECUTED
a0009714:	eb00045f 	bl	a000a898 <printk>                              <== NOT EXECUTED
    file,                                                             
    line,                                                             
    (func) ? ", function: " : "",                                     
    (func) ? func : ""                                                
  );                                                                  
  rtems_fatal_error_occurred(0);                                      
a0009718:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000971c:	eb001153 	bl	a000dc70 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a001462c <__env_lock>:
a001462c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0014630 <__env_unlock>:
a0014630:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006ab4 <__getpid>: #include <unistd.h> pid_t __getpid(void) { return getpid();
a0006ab4:	eaffffff 	b	a0006ab8 <getpid>                               <== NOT EXECUTED
                                                                      

a0025a34 <__kill>: #endif int __kill( pid_t pid, int sig ) { return 0; }
a0025a34:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0025a38:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a002595c <_calloc_r>: struct _reent *ignored __attribute__((unused)), size_t elements, size_t size ) { return calloc( elements, size );
a002595c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0025960:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0025964:	eaff9513 	b	a000adb8 <calloc>                               <== NOT EXECUTED
                                                                      

a0007d60 <_chown_helper>: const char *path, uid_t owner, gid_t group, int follow_link ) {
a0007d60:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0007d64:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a0007d68:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
a0007d6c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0007d70:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
a0007d74:	e1a05822 	lsr	r5, r2, #16                                   <== NOT EXECUTED
a0007d78:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0007d7c:	e1a06821 	lsr	r6, r1, #16                                   <== NOT EXECUTED
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
a0007d80:	eb003349 	bl	a0014aac <strlen>                              <== NOT EXECUTED
a0007d84:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0007d88:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0007d8c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0007d90:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0007d94:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0007d98:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
a0007d9c:	eb000030 	bl	a0007e64 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a0007da0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
a0007da4:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
a0007da8:	1a000008 	bne	a0007dd0 <_chown_helper+0x70>                 <== NOT EXECUTED
    return -1;                                                        
                                                                      
  result = (*loc.ops->chown_h)( &loc, owner, group );                 
a0007dac:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0007db0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0007db4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007db8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0007dbc:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0007dc0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007dc4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0007dc8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007dcc:	eb00005e 	bl	a0007f4c <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a0007dd0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007dd4:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0007dd8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a0006ef4 <_fcntl_r>: int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg );
a0006ef4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0006ef8:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0006efc:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0006f00:	eaffff80 	b	a0006d08 <fcntl>                                <== NOT EXECUTED
                                                                      

a0015e58 <_free_r>: void _free_r( struct _reent *ignored __attribute__((unused)), void *ptr ) { free( ptr );
a0015e58:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0015e5c:	eaffc144 	b	a0006374 <free>                                 <== NOT EXECUTED
                                                                      

a0015ef0 <_fstat_r>: struct _reent *ptr __attribute__((unused)), int fd, struct stat *buf ) { return fstat( fd, buf );
a0015ef0:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0015ef4:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0015ef8:	eaffffd8 	b	a0015e60 <fstat>                                <== NOT EXECUTED
                                                                      

a0025a14 <_getpid_r>: pid_t _getpid_r( struct _reent *ptr __attribute__((unused)) ) { return getpid(); }
a0025a14:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0025a18:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00064bc <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp );
a00064bc:	eaffffe1 	b	a0006448 <gettimeofday>                         <== NOT EXECUTED
                                                                      

a00064b0 <_gettimeofday_r>: struct _reent *ignored_reentrancy_stuff __attribute__((unused)), struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp );
a00064b0:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a00064b4:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a00064b8:	eaffffe2 	b	a0006448 <gettimeofday>                         <== NOT EXECUTED
                                                                      

a0015efc <_isatty_r>: int _isatty_r( struct _reent *ptr __attribute__((unused)), int fd ) { return isatty( fd );
a0015efc:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0015f00:	ea0001d0 	b	a0016648 <isatty>                               <== NOT EXECUTED
                                                                      

a0025a2c <_kill_r>: #include <reent.h> int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { return 0; }
a0025a2c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0025a30:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0009bf8 <_link_r>: struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { return link( existing, new );
a0009bf8:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0009bfc:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0009c00:	eaffffbe 	b	a0009b00 <link>                                 <== NOT EXECUTED
                                                                      

a001602c <_lseek_r>: int fd, off_t offset, int whence ) { return lseek( fd, offset, whence );
a001602c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0016030:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0016034:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0016038:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a001603c:	eaffffb0 	b	a0015f04 <lseek>                                <== NOT EXECUTED
                                                                      

a0008634 <_lstat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
a0008634:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0008638:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a000863c:	eaffffd9 	b	a00085a8 <lstat>                                <== NOT EXECUTED
                                                                      

a0016040 <_malloc_r>: void *_malloc_r( struct _reent *ignored __attribute__((unused)), size_t size ) { return malloc( size );
a0016040:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0016044:	eaffc1b1 	b	a0006710 <malloc>                               <== NOT EXECUTED
                                                                      

a0007200 <_open_r>: const char *buf, int flags, int mode ) { return open( buf, flags, mode );
a0007200:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0007204:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0007208:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000720c:	eaffff5f 	b	a0006f90 <open>                                 <== NOT EXECUTED
                                                                      

a0016188 <_read_r>: int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes );
a0016188:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a001618c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0016190:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0016194:	eaffffcd 	b	a00160d0 <read>                                 <== NOT EXECUTED
                                                                      

a0016198 <_realloc_r>: struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { return realloc( ptr, size );
a0016198:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a001619c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a00161a0:	ea000012 	b	a00161f0 <realloc>                              <== NOT EXECUTED
                                                                      

a000aabc <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) {
a000aabc:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Get the parent node of the old path to be renamed. Find the parent path.
   */                                                                 
                                                                      
  old_parent_pathlen = rtems_filesystem_dirname ( old );              
a000aac0:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
int _rename_r(                                                        
  struct _reent *ptr __attribute__((unused)),                         
  const char    *old,                                                 
  const char    *new                                                  
)                                                                     
{                                                                     
a000aac4:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a000aac8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a000aacc:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Get the parent node of the old path to be renamed. Find the parent path.
   */                                                                 
                                                                      
  old_parent_pathlen = rtems_filesystem_dirname ( old );              
a000aad0:	ebfffa11 	bl	a000931c <rtems_filesystem_dirname>            <== NOT EXECUTED
                                                                      
  if ( old_parent_pathlen == 0 )                                      
a000aad4:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
a000aad8:	1a00005a 	bne	a000ac48 <_rename_r+0x18c>                    <== NOT EXECUTED
    rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );       
a000aadc:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a000aae0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000aae4:	e28d1044 	add	r1, sp, #68	; 0x44                            <== NOT EXECUTED
a000aae8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000aaec:	eb0000eb 	bl	a000aea0 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
  rtems_filesystem_location_info_t    old_parent_loc;                 
  rtems_filesystem_location_info_t    new_parent_loc;                 
  int                                 i;                              
  int                                 result;                         
  const char                         *name;                           
  bool                                free_old_parentloc = false;     
a000aaf0:	e1a08007 	mov	r8, r7                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  old_loc = old_parent_loc;                                           
a000aaf4:	e28dc02c 	add	ip, sp, #44	; 0x2c                            <== NOT EXECUTED
a000aaf8:	e1a0e004 	mov	lr, r4                                        <== NOT EXECUTED
a000aafc:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000ab00:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000ab04:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  name = old + old_parent_pathlen;                                    
a000ab08:	e0855007 	add	r5, r5, r7                                    <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000ab0c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  old_loc = old_parent_loc;                                           
a000ab10:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  name = old + old_parent_pathlen;                                    
a000ab14:	e58d5040 	str	r5, [sp, #64]	; 0x40                          <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000ab18:	eb0035f5 	bl	a00182f4 <strlen>                              <== NOT EXECUTED
a000ab1c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000ab20:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ab24:	ebfffa0b 	bl	a0009358 <rtems_filesystem_prefix_separators>  <== NOT EXECUTED
a000ab28:	e0855000 	add	r5, r5, r0                                    <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
a000ab2c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  old_loc = old_parent_loc;                                           
  name = old + old_parent_pathlen;                                    
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000ab30:	e58d5040 	str	r5, [sp, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
a000ab34:	eb0035ee 	bl	a00182f4 <strlen>                              <== NOT EXECUTED
a000ab38:	e28d702c 	add	r7, sp, #44	; 0x2c                            <== NOT EXECUTED
a000ab3c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000ab40:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000ab44:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ab48:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a000ab4c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000ab50:	ebfff9bf 	bl	a0009254 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
                                                    0, &old_loc, false );
  if ( result != 0 ) {                                                
a000ab54:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ab58:	1a000032 	bne	a000ac28 <_rename_r+0x16c>                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Get the parent of the new node we are renaming to.               
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );         
a000ab5c:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
a000ab60:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000ab64:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000ab68:	e28d1044 	add	r1, sp, #68	; 0x44                            <== NOT EXECUTED
a000ab6c:	eb0000cb 	bl	a000aea0 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
                                                                      
  result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
a000ab70:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000ab74:	e59d0044 	ldr	r0, [sp, #68]	; 0x44                          <== NOT EXECUTED
a000ab78:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000ab7c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000ab80:	e0860000 	add	r0, r6, r0                                    <== NOT EXECUTED
a000ab84:	e28d2040 	add	r2, sp, #64	; 0x40                            <== NOT EXECUTED
a000ab88:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  if ( result != 0 ) {                                                
a000ab8c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ab90:	1a000038 	bne	a000ac78 <_rename_r+0x1bc>                    <== NOT EXECUTED
  /*                                                                  
   *  Check to see if the caller is trying to rename across file system
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {         
a000ab94:	e59d3014 	ldr	r3, [sp, #20]                                 <== NOT EXECUTED
a000ab98:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000ab9c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000aba0:	1a000013 	bne	a000abf4 <_rename_r+0x138>                    <== NOT EXECUTED
      rtems_filesystem_freenode( &old_parent_loc );                   
    rtems_filesystem_freenode( &old_loc );                            
    rtems_set_errno_and_return_minus_one( EXDEV );                    
  }                                                                   
                                                                      
  result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
a000aba4:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000aba8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000abac:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000abb0:	e593c040 	ldr	ip, [r3, #64]	; 0x40                          <== NOT EXECUTED
a000abb4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000abb8:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
a000abbc:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
a000abc0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &new_parent_loc );                       
a000abc4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000abc8:	ebfffa76 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
  if ( free_old_parentloc )                                           
a000abcc:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000abd0:	1a000004 	bne	a000abe8 <_rename_r+0x12c>                    <== NOT EXECUTED
    rtems_filesystem_freenode( &old_parent_loc );                     
  rtems_filesystem_freenode( &old_loc );                              
a000abd4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000abd8:	ebfffa72 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a000abdc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000abe0:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a000abe4:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
                                                                      
  rtems_filesystem_freenode( &new_parent_loc );                       
  if ( free_old_parentloc )                                           
    rtems_filesystem_freenode( &old_parent_loc );                     
a000abe8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000abec:	ebfffa6d 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
a000abf0:	eafffff7 	b	a000abd4 <_rename_r+0x118>                      <== NOT EXECUTED
   *  Check to see if the caller is trying to rename across file system
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {         
    rtems_filesystem_freenode( &new_parent_loc );                     
a000abf4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000abf8:	ebfffa6a 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    if ( free_old_parentloc )                                         
a000abfc:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000ac00:	0a000001 	beq	a000ac0c <_rename_r+0x150>                    <== NOT EXECUTED
      rtems_filesystem_freenode( &old_parent_loc );                   
a000ac04:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ac08:	ebfffa66 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_filesystem_freenode( &old_loc );                            
a000ac0c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ac10:	ebfffa64 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EXDEV );                    
a000ac14:	eb0028b3 	bl	a0014ee8 <__errno>                             <== NOT EXECUTED
a000ac18:	e3a03012 	mov	r3, #18                                       <== NOT EXECUTED
a000ac1c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000ac20:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000ac24:	eaffffec 	b	a000abdc <_rename_r+0x120>                      <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &old_loc, false );
  if ( result != 0 ) {                                                
    if ( free_old_parentloc )                                         
a000ac28:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000ac2c:	1a000001 	bne	a000ac38 <_rename_r+0x17c>                    <== NOT EXECUTED
      rtems_filesystem_freenode( &old_parent_loc );                   
    return -1;                                                        
a000ac30:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000ac34:	eaffffe8 	b	a000abdc <_rename_r+0x120>                      <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &old_loc, false );
  if ( result != 0 ) {                                                
    if ( free_old_parentloc )                                         
      rtems_filesystem_freenode( &old_parent_loc );                   
a000ac38:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ac3c:	ebfffa59 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    return -1;                                                        
a000ac40:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000ac44:	eaffffe4 	b	a000abdc <_rename_r+0x120>                      <== NOT EXECUTED
  old_parent_pathlen = rtems_filesystem_dirname ( old );              
                                                                      
  if ( old_parent_pathlen == 0 )                                      
    rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );       
  else {                                                              
    result = rtems_filesystem_evaluate_path( old, old_parent_pathlen, 
a000ac48:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ac4c:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a000ac50:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000ac54:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a000ac58:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ac5c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000ac60:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000ac64:	ebfff996 	bl	a00092c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                             RTEMS_LIBIO_PERMS_WRITE, 
                                             &old_parent_loc,         
                                             false );                 
    if ( result != 0 )                                                
a000ac68:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ac6c:	1affffef 	bne	a000ac30 <_rename_r+0x174>                    <== NOT EXECUTED
      return -1;                                                      
                                                                      
    free_old_parentloc = true;                                        
a000ac70:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
a000ac74:	eaffff9e 	b	a000aaf4 <_rename_r+0x38>                       <== NOT EXECUTED
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );         
                                                                      
  result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
  if ( result != 0 ) {                                                
    rtems_filesystem_freenode( &new_parent_loc );                     
a000ac78:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ac7c:	ebfffa49 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    if ( free_old_parentloc )                                         
a000ac80:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a000ac84:	0a000001 	beq	a000ac90 <_rename_r+0x1d4>                    <== NOT EXECUTED
      rtems_filesystem_freenode( &old_parent_loc );                   
a000ac88:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ac8c:	ebfffa45 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_filesystem_freenode( &old_loc );                            
a000ac90:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ac94:	ebfffa43 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    return -1;                                                        
a000ac98:	e3e06000 	mvn	r6, #0                                        <== NOT EXECUTED
a000ac9c:	eaffffce 	b	a000abdc <_rename_r+0x120>                      <== NOT EXECUTED
                                                                      

a00073a8 <_stat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
a00073a8:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a00073ac:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a00073b0:	eaffffd8 	b	a0007318 <stat>                                 <== NOT EXECUTED
                                                                      

a00092d0 <_times>: #endif clock_t _times( struct tms *ptms ) {
a00092d0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_interval ticks;                                               
                                                                      
  if ( !ptms )                                                        
a00092d4:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
#endif                                                                
                                                                      
clock_t _times(                                                       
   struct tms  *ptms                                                  
)                                                                     
{                                                                     
a00092d8:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
  rtems_interval ticks;                                               
                                                                      
  if ( !ptms )                                                        
a00092dc:	0a000020 	beq	a0009364 <_times+0x94>                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This call does not depend on TOD being initialized and can't fail.
   */                                                                 
                                                                      
  ticks = rtems_clock_get_ticks_since_boot();                         
a00092e0:	eb00011d 	bl	a000975c <rtems_clock_get_ticks_since_boot>    <== NOT EXECUTED
    {                                                                 
      Timestamp_Control per_tick;                                     
      uint32_t          ticks;                                        
      uint32_t          fractional_ticks;                             
                                                                      
      _Timestamp_Set(                                                 
a00092e4:	e59f308c 	ldr	r3, [pc, #140]	; a0009378 <_times+0xa8>       <== NOT EXECUTED
a00092e8:	e59f108c 	ldr	r1, [pc, #140]	; a000937c <_times+0xac>       <== NOT EXECUTED
a00092ec:	e59fe08c 	ldr	lr, [pc, #140]	; a0009380 <_times+0xb0>       <== NOT EXECUTED
a00092f0:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
a00092f4:	e3a03ffa 	mov	r3, #1000	; 0x3e8                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This call does not depend on TOD being initialized and can't fail.
   */                                                                 
                                                                      
  ticks = rtems_clock_get_ticks_since_boot();                         
a00092f8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    {                                                                 
      Timestamp_Control per_tick;                                     
      uint32_t          ticks;                                        
      uint32_t          fractional_ticks;                             
                                                                      
      _Timestamp_Set(                                                 
a00092fc:	e0030392 	mul	r3, r2, r3                                    <== NOT EXECUTED
a0009300:	e1a0c4a3 	lsr	ip, r3, #9                                    <== NOT EXECUTED
a0009304:	e08c0c91 	umull	r0, ip, r1, ip                              <== NOT EXECUTED
a0009308:	e08e1e92 	umull	r1, lr, r2, lr                              <== NOT EXECUTED
a000930c:	e59f2070 	ldr	r2, [pc, #112]	; a0009384 <_times+0xb4>       <== NOT EXECUTED
a0009310:	e1a0c3ac 	lsr	ip, ip, #7                                    <== NOT EXECUTED
a0009314:	e1a0e92e 	lsr	lr, lr, #18                                   <== NOT EXECUTED
a0009318:	e00c0c92 	mul	ip, r2, ip                                    <== NOT EXECUTED
            TOD_MICROSECONDS_PER_SECOND,                              
        (rtems_configuration_get_nanoseconds_per_tick() %             
            TOD_NANOSECONDS_PER_SECOND)                               
      );                                                              
                                                                      
      _Timestamp_Divide(                                              
a000931c:	e59f2064 	ldr	r2, [pc, #100]	; a0009388 <_times+0xb8>       <== NOT EXECUTED
    {                                                                 
      Timestamp_Control per_tick;                                     
      uint32_t          ticks;                                        
      uint32_t          fractional_ticks;                             
                                                                      
      _Timestamp_Set(                                                 
a0009320:	e06cc003 	rsb	ip, ip, r3                                    <== NOT EXECUTED
            TOD_MICROSECONDS_PER_SECOND,                              
        (rtems_configuration_get_nanoseconds_per_tick() %             
            TOD_NANOSECONDS_PER_SECOND)                               
      );                                                              
                                                                      
      _Timestamp_Divide(                                              
a0009324:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0009328:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
a000932c:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
a0009330:	e28d200c 	add	r2, sp, #12                                   <== NOT EXECUTED
a0009334:	e2800084 	add	r0, r0, #132	; 0x84                           <== NOT EXECUTED
    {                                                                 
      Timestamp_Control per_tick;                                     
      uint32_t          ticks;                                        
      uint32_t          fractional_ticks;                             
                                                                      
      _Timestamp_Set(                                                 
a0009338:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
a000933c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
            TOD_MICROSECONDS_PER_SECOND,                              
        (rtems_configuration_get_nanoseconds_per_tick() %             
            TOD_NANOSECONDS_PER_SECOND)                               
      );                                                              
                                                                      
      _Timestamp_Divide(                                              
a0009340:	eb000e7c 	bl	a000cd38 <_Timespec_Divide>                    <== NOT EXECUTED
        &_Thread_Executing->cpu_time_used,                            
        &per_tick,                                                    
        &ticks,                                                       
        &fractional_ticks                                             
      );                                                              
      ptms->tms_utime = ticks;                                        
a0009344:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
    }                                                                 
  #else                                                               
    ptms->tms_utime  = _Thread_Executing->cpu_time_used;              
  #endif                                                              
  ptms->tms_stime  = ticks;                                           
  ptms->tms_cutime = 0;                                               
a0009348:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      ptms->tms_utime = ticks;                                        
    }                                                                 
  #else                                                               
    ptms->tms_utime  = _Thread_Executing->cpu_time_used;              
  #endif                                                              
  ptms->tms_stime  = ticks;                                           
a000934c:	e8840024 	stm	r4, {r2, r5}                                  <== NOT EXECUTED
  ptms->tms_cutime = 0;                                               
a0009350:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  ptms->tms_cstime = 0;                                               
a0009354:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
                                                                      
  return ticks;                                                       
a0009358:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
}                                                                     
a000935c:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a0009360:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_interval ticks;                                               
                                                                      
  if ( !ptms )                                                        
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0009364:	eb002027 	bl	a0011408 <__errno>                             <== NOT EXECUTED
a0009368:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a000936c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0009370:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0009374:	eafffff8 	b	a000935c <_times+0x8c>                          <== NOT EXECUTED
                                                                      

a0009390 <_times_r>: clock_t _times_r( struct _reent *ptr __attribute__((unused)), struct tms *ptms ) { return _times( ptms );
a0009390:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0009394:	eaffffcd 	b	a00092d0 <_times>                               <== NOT EXECUTED
                                                                      

a000a24c <_unlink_r>: int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { return unlink( path );
a000a24c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000a250:	eaffffa5 	b	a000a0ec <unlink>                               <== NOT EXECUTED
                                                                      

a00161a4 <_write_r>: int fd, const void *buf, size_t nbytes ) { return write( fd, buf, nbytes );
a00161a4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a00161a8:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a00161ac:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a00161b0:	ea00005c 	b	a0016328 <write>                                <== NOT EXECUTED
                                                                      

a00082ac <access>: int access( const char *path, int amode ) {
a00082ac:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a00082b0:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a00082b4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  struct stat statbuf;                                                
                                                                      
  if ( stat(path, &statbuf) )                                         
a00082b8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00082bc:	eb000617 	bl	a0009b20 <stat>                                <== NOT EXECUTED
a00082c0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00082c4:	1a00000a 	bne	a00082f4 <access+0x48>                        <== NOT EXECUTED
    return -1;                                                        
                                                                      
  if ( amode & R_OK ) {                                               
a00082c8:	e3140004 	tst	r4, #4                                        <== NOT EXECUTED
a00082cc:	1a00000a 	bne	a00082fc <access+0x50>                        <== NOT EXECUTED
    if (!( statbuf.st_mode & S_IREAD ))                               
      return -1;                                                      
  }                                                                   
                                                                      
  if ( amode & W_OK ) {                                               
a00082d0:	e3140002 	tst	r4, #2                                        <== NOT EXECUTED
a00082d4:	1a000003 	bne	a00082e8 <access+0x3c>                        <== NOT EXECUTED
    if ( !( statbuf.st_mode & S_IWRITE ) )                            
      return -1;                                                      
  }                                                                   
                                                                      
  if ( amode & X_OK ) {                                               
a00082d8:	e2140001 	ands	r0, r4, #1                                   <== NOT EXECUTED
a00082dc:	1a00000b 	bne	a0008310 <access+0x64>                        <== NOT EXECUTED
    if ( !( statbuf.st_mode & S_IEXEC ) )                             
      return -1;                                                      
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a00082e0:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a00082e4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
    if (!( statbuf.st_mode & S_IREAD ))                               
      return -1;                                                      
  }                                                                   
                                                                      
  if ( amode & W_OK ) {                                               
    if ( !( statbuf.st_mode & S_IWRITE ) )                            
a00082e8:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a00082ec:	e3130080 	tst	r3, #128	; 0x80                               <== NOT EXECUTED
a00082f0:	1afffff8 	bne	a00082d8 <access+0x2c>                        <== NOT EXECUTED
      return -1;                                                      
a00082f4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00082f8:	eafffff8 	b	a00082e0 <access+0x34>                          <== NOT EXECUTED
                                                                      
  if ( stat(path, &statbuf) )                                         
    return -1;                                                        
                                                                      
  if ( amode & R_OK ) {                                               
    if (!( statbuf.st_mode & S_IREAD ))                               
a00082fc:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0008300:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0008304:	1afffff1 	bne	a00082d0 <access+0x24>                        <== NOT EXECUTED
      return -1;                                                      
  }                                                                   
                                                                      
  if ( amode & W_OK ) {                                               
    if ( !( statbuf.st_mode & S_IWRITE ) )                            
      return -1;                                                      
a0008308:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000830c:	eafffff3 	b	a00082e0 <access+0x34>                          <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( amode & X_OK ) {                                               
    if ( !( statbuf.st_mode & S_IEXEC ) )                             
a0008310:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0008314:	e3130040 	tst	r3, #64	; 0x40                                <== NOT EXECUTED
      return -1;                                                      
  }                                                                   
                                                                      
  return 0;                                                           
a0008318:	03e00000 	mvneq	r0, #0                                      <== NOT EXECUTED
a000831c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a0008320:	eaffffee 	b	a00082e0 <access+0x34>                          <== NOT EXECUTED
                                                                      

a0007b18 <cfgetispeed>: speed_t cfgetispeed( const struct termios *tp ) { return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
a0007b18:	e1d000ba 	ldrh	r0, [r0, #10]                                <== NOT EXECUTED
}                                                                     
a0007b1c:	e3c00eff 	bic	r0, r0, #4080	; 0xff0                         <== NOT EXECUTED
a0007b20:	e1a00980 	lsl	r0, r0, #19                                   <== NOT EXECUTED
a0007b24:	e1a009a0 	lsr	r0, r0, #19                                   <== NOT EXECUTED
a0007b28:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007b2c <cfgetospeed>: speed_t cfgetospeed( const struct termios *tp ) { return tp->c_cflag & CBAUD;
a0007b2c:	e5900008 	ldr	r0, [r0, #8]                                  <== NOT EXECUTED
}                                                                     
a0007b30:	e3c00eff 	bic	r0, r0, #4080	; 0xff0                         <== NOT EXECUTED
a0007b34:	e1a00980 	lsl	r0, r0, #19                                   <== NOT EXECUTED
a0007b38:	e1a009a0 	lsr	r0, r0, #19                                   <== NOT EXECUTED
a0007b3c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007b40 <cfsetispeed>: int cfsetispeed( struct termios *tp, speed_t speed ) { if ( speed & ~CBAUD )
a0007b40:	e3c13a01 	bic	r3, r1, #4096	; 0x1000                        <== NOT EXECUTED
a0007b44:	e3d3300f 	bics	r3, r3, #15                                  <== NOT EXECUTED
                                                                      
int cfsetispeed(                                                      
  struct termios *tp,                                                 
  speed_t         speed                                               
)                                                                     
{                                                                     
a0007b48:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0007b4c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
  if ( speed & ~CBAUD )                                               
a0007b50:	1a000006 	bne	a0007b70 <cfsetispeed+0x30>                   <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD)); 
a0007b54:	e590c008 	ldr	ip, [r0, #8]                                  <== NOT EXECUTED
  return 0;                                                           
a0007b58:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( speed & ~CBAUD )                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD)); 
a0007b5c:	e3cc3201 	bic	r3, ip, #268435456	; 0x10000000               <== NOT EXECUTED
a0007b60:	e3c3380f 	bic	r3, r3, #983040	; 0xf0000                     <== NOT EXECUTED
a0007b64:	e1831801 	orr	r1, r3, r1, lsl #16                           <== NOT EXECUTED
a0007b68:	e5821008 	str	r1, [r2, #8]                                  <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0007b6c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  struct termios *tp,                                                 
  speed_t         speed                                               
)                                                                     
{                                                                     
  if ( speed & ~CBAUD )                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0007b70:	eb002db1 	bl	a001323c <__errno>                             <== NOT EXECUTED
a0007b74:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007b78:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007b7c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007b80:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0007b84 <cfsetospeed>: int cfsetospeed( struct termios *tp, speed_t speed ) { if ( speed & ~CBAUD )
a0007b84:	e3c13a01 	bic	r3, r1, #4096	; 0x1000                        <== NOT EXECUTED
a0007b88:	e3d3300f 	bics	r3, r3, #15                                  <== NOT EXECUTED
                                                                      
int cfsetospeed(                                                      
  struct termios *tp,                                                 
  speed_t         speed                                               
)                                                                     
{                                                                     
a0007b8c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0007b90:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
  if ( speed & ~CBAUD )                                               
a0007b94:	1a000006 	bne	a0007bb4 <cfsetospeed+0x30>                   <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;                       
a0007b98:	e590c008 	ldr	ip, [r0, #8]                                  <== NOT EXECUTED
  return 0;                                                           
a0007b9c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( speed & ~CBAUD )                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;                       
a0007ba0:	e3cc3a01 	bic	r3, ip, #4096	; 0x1000                        <== NOT EXECUTED
a0007ba4:	e3c3300f 	bic	r3, r3, #15                                   <== NOT EXECUTED
a0007ba8:	e1811003 	orr	r1, r1, r3                                    <== NOT EXECUTED
a0007bac:	e5821008 	str	r1, [r2, #8]                                  <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0007bb0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  struct termios *tp,                                                 
  speed_t         speed                                               
)                                                                     
{                                                                     
  if ( speed & ~CBAUD )                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0007bb4:	eb002da0 	bl	a001323c <__errno>                             <== NOT EXECUTED
a0007bb8:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007bbc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007bc0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007bc4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000eb34 <chdir>: #include <rtems/seterr.h> int chdir( const char *pathname ) {
a000eb34:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if ( !pathname )                                                    
a000eb38:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int chdir(                                                            
  const char *pathname                                                
)                                                                     
{                                                                     
a000eb3c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if ( !pathname )                                                    
a000eb40:	0a00001f 	beq	a000ebc4 <chdir+0x90>                         <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  /*                                                                  
   *  Get the node where we wish to go.                               
   */                                                                 
  result = rtems_filesystem_evaluate_path(                            
a000eb44:	eb000e2b 	bl	a00123f8 <strlen>                              <== NOT EXECUTED
a000eb48:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a000eb4c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000eb50:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000eb54:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000eb58:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000eb5c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000eb60:	ebffde57 	bl	a00064c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
    pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
  if ( result != 0 )                                                  
a000eb64:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
     return -1;                                                       
a000eb68:	13e04000 	mvnne	r4, #0                                      <== NOT EXECUTED
  /*                                                                  
   *  Get the node where we wish to go.                               
   */                                                                 
  result = rtems_filesystem_evaluate_path(                            
    pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
  if ( result != 0 )                                                  
a000eb6c:	0a000002 	beq	a000eb7c <chdir+0x48>                         <== NOT EXECUTED
  rtems_filesystem_freenode( &rtems_filesystem_current );             
                                                                      
  rtems_filesystem_current = loc;                                     
                                                                      
  return 0;                                                           
}                                                                     
a000eb70:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000eb74:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a000eb78:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
     return -1;                                                       
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
a000eb7c:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000eb80:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000eb84:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000eb88:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000eb8c:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000eb90:	1a000010 	bne	a000ebd8 <chdir+0xa4>                         <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  }                                                                   
                                                                      
  rtems_filesystem_freenode( &rtems_filesystem_current );             
a000eb94:	e59f6058 	ldr	r6, [pc, #88]	; a000ebf4 <chdir+0xc0>         <== NOT EXECUTED
a000eb98:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000eb9c:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
a000eba0:	ebffde81 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  rtems_filesystem_current = loc;                                     
a000eba4:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000eba8:	e596c000 	ldr	ip, [r6]                                      <== NOT EXECUTED
a000ebac:	e5946000 	ldr	r6, [r4]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
a000ebb0:	e1a04005 	mov	r4, r5                                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
  }                                                                   
                                                                      
  rtems_filesystem_freenode( &rtems_filesystem_current );             
                                                                      
  rtems_filesystem_current = loc;                                     
a000ebb4:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
a000ebb8:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000ebbc:	e58c6000 	str	r6, [ip]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
a000ebc0:	eaffffea 	b	a000eb70 <chdir+0x3c>                           <== NOT EXECUTED
{                                                                     
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if ( !pathname )                                                    
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a000ebc4:	eb000a4c 	bl	a00114fc <__errno>                             <== NOT EXECUTED
a000ebc8:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a000ebcc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000ebd0:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a000ebd4:	eaffffe5 	b	a000eb70 <chdir+0x3c>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
    rtems_filesystem_freenode( &loc );                                
a000ebd8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ebdc:	ebffde72 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a000ebe0:	eb000a45 	bl	a00114fc <__errno>                             <== NOT EXECUTED
a000ebe4:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a000ebe8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000ebec:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a000ebf0:	eaffffde 	b	a000eb70 <chdir+0x3c>                           <== NOT EXECUTED
                                                                      

a0007cf4 <chmod>: int chmod( const char *path, mode_t mode ) {
a0007cf4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0007cf8:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0007cfc:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0007d00:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  int                              status;                            
  rtems_filesystem_location_info_t loc;                               
  int                              result;                            
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
a0007d04:	eb003368 	bl	a0014aac <strlen>                              <== NOT EXECUTED
a0007d08:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0007d0c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0007d10:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0007d14:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0007d18:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0007d1c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007d20:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0007d24:	eb00004e 	bl	a0007e64 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
  if ( status != 0 )                                                  
a0007d28:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
a0007d2c:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
  int                              status;                            
  rtems_filesystem_location_info_t loc;                               
  int                              result;                            
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
  if ( status != 0 )                                                  
a0007d30:	1a000007 	bne	a0007d54 <chmod+0x60>                         <== NOT EXECUTED
    return -1;                                                        
                                                                      
  result = (*loc.handlers->fchmod_h)( &loc, mode );                   
a0007d34:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0007d38:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0007d3c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007d40:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
a0007d44:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007d48:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0007d4c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007d50:	eb00007d 	bl	a0007f4c <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a0007d54:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007d58:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0007d5c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0007ddc <chown>: int chown( const char *path, uid_t owner, gid_t group ) {
a0007ddc:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a0007de0:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
  return _chown_helper( path, owner, group, true );                   
a0007de4:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
a0007de8:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
a0007dec:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0007df0:	eaffffda 	b	a0007d60 <_chown_helper>                        <== NOT EXECUTED
                                                                      

a0006304 <chroot>: #include <rtems/seterr.h> int chroot( const char *pathname ) {
a0006304:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  int                               result;                           
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /* an automatic call to new private env the first time */           
  if (rtems_current_user_env == &rtems_global_user_env) {             
a0006308:	e59f50b8 	ldr	r5, [pc, #184]	; a00063c8 <chroot+0xc4>       <== NOT EXECUTED
a000630c:	e59f30b8 	ldr	r3, [pc, #184]	; a00063cc <chroot+0xc8>       <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int chroot(                                                           
  const char *pathname                                                
)                                                                     
{                                                                     
a0006310:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
  int                               result;                           
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /* an automatic call to new private env the first time */           
  if (rtems_current_user_env == &rtems_global_user_env) {             
a0006314:	e5954000 	ldr	r4, [r5]                                      <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int chroot(                                                           
  const char *pathname                                                
)                                                                     
{                                                                     
a0006318:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  int                               result;                           
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /* an automatic call to new private env the first time */           
  if (rtems_current_user_env == &rtems_global_user_env) {             
a000631c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a0006320:	0a000018 	beq	a0006388 <chroot+0x84>                        <== NOT EXECUTED
   rtems_libio_set_private_env(); /* try to set a new private env*/   
   if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
  }                                                                   
                                                                      
  result = chdir(pathname);                                           
a0006324:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006328:	eb002201 	bl	a000eb34 <chdir>                               <== NOT EXECUTED
  if (result) {                                                       
a000632c:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
a0006330:	1a00001d 	bne	a00063ac <chroot+0xa8>                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( errno );                    
  }                                                                   
                                                                      
  /* clone the new root location */                                   
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
a0006334:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0006338:	e59f0090 	ldr	r0, [pc, #144]	; a00063d0 <chroot+0xcc>       <== NOT EXECUTED
a000633c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0006340:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006344:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0006348:	eb00005d 	bl	a00064c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a000634c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0006350:	1a000015 	bne	a00063ac <chroot+0xa8>                        <== NOT EXECUTED
    /* our cwd has changed, though - but there is no easy way of return :-( */
    rtems_set_errno_and_return_minus_one( errno );                    
  }                                                                   
  rtems_filesystem_freenode(&rtems_filesystem_root);                  
a0006354:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0006358:	e2800018 	add	r0, r0, #24                                   <== NOT EXECUTED
a000635c:	eb000092 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
  rtems_filesystem_root = loc;                                        
a0006360:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0006364:	e595c000 	ldr	ip, [r5]                                      <== NOT EXECUTED
a0006368:	e5945000 	ldr	r5, [r4]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
a000636c:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
    /* our cwd has changed, though - but there is no easy way of return :-( */
    rtems_set_errno_and_return_minus_one( errno );                    
  }                                                                   
  rtems_filesystem_freenode(&rtems_filesystem_root);                  
  rtems_filesystem_root = loc;                                        
a0006370:	e28cc018 	add	ip, ip, #24                                   <== NOT EXECUTED
a0006374:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0006378:	e58c5000 	str	r5, [ip]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000637c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006380:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0006384:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  int                               result;                           
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /* an automatic call to new private env the first time */           
  if (rtems_current_user_env == &rtems_global_user_env) {             
   rtems_libio_set_private_env(); /* try to set a new private env*/   
a0006388:	eb00051e 	bl	a0007808 <rtems_libio_set_private_env>         <== NOT EXECUTED
   if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 
a000638c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0006390:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a0006394:	1affffe2 	bne	a0006324 <chroot+0x20>                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
a0006398:	eb002c57 	bl	a00114fc <__errno>                             <== NOT EXECUTED
a000639c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
a00063a0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00063a4:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a00063a8:	eafffff3 	b	a000637c <chroot+0x78>                          <== NOT EXECUTED
  }                                                                   
                                                                      
  /* clone the new root location */                                   
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
    /* our cwd has changed, though - but there is no easy way of return :-( */
    rtems_set_errno_and_return_minus_one( errno );                    
a00063ac:	eb002c52 	bl	a00114fc <__errno>                             <== NOT EXECUTED
a00063b0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a00063b4:	eb002c50 	bl	a00114fc <__errno>                             <== NOT EXECUTED
a00063b8:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00063bc:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a00063c0:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
a00063c4:	eaffffec 	b	a000637c <chroot+0x78>                          <== NOT EXECUTED
                                                                      

a000e3b0 <close>: ) { rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd);
a000e3b0:	e59f3068 	ldr	r3, [pc, #104]	; a000e420 <close+0x70>        
#include <rtems/libio_.h>                                             
                                                                      
int close(                                                            
  int  fd                                                             
)                                                                     
{                                                                     
a000e3b4:	e92d4030 	push	{r4, r5, lr}                                 
  rtems_libio_t      *iop;                                            
  rtems_status_code   rc;                                             
                                                                      
  rtems_libio_check_fd(fd);                                           
a000e3b8:	e5933000 	ldr	r3, [r3]                                      
a000e3bc:	e1500003 	cmp	r0, r3                                        
a000e3c0:	2a000011 	bcs	a000e40c <close+0x5c>                         
  iop = rtems_libio_iop(fd);                                          
a000e3c4:	e59f3058 	ldr	r3, [pc, #88]	; a000e424 <close+0x74>         
a000e3c8:	e3a04038 	mov	r4, #56	; 0x38                                
a000e3cc:	e5933000 	ldr	r3, [r3]                                      
a000e3d0:	e0243490 	mla	r4, r0, r4, r3                                
  rtems_libio_check_is_open(iop);                                     
a000e3d4:	e5943014 	ldr	r3, [r4, #20]                                 
a000e3d8:	e3130c01 	tst	r3, #256	; 0x100                              
a000e3dc:	0a00000a 	beq	a000e40c <close+0x5c>                         
                                                                      
  rc = RTEMS_SUCCESSFUL;                                              
  rc = (*iop->pathinfo.handlers->close_h)( iop );                     
a000e3e0:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a000e3e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e3e8:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000e3ec:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000e3f0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &iop->pathinfo );                        
a000e3f4:	e2840018 	add	r0, r4, #24                                   <== NOT EXECUTED
a000e3f8:	ebffdfd8 	bl	a0006360 <rtems_filesystem_freenode>           <== NOT EXECUTED
  rtems_libio_free( iop );                                            
a000e3fc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e400:	eb0000a3 	bl	a000e694 <rtems_libio_free>                    <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
a000e404:	e1a00005 	mov	r0, r5                                        
a000e408:	e8bd8030 	pop	{r4, r5, pc}                                  
  rtems_libio_t      *iop;                                            
  rtems_status_code   rc;                                             
                                                                      
  rtems_libio_check_fd(fd);                                           
  iop = rtems_libio_iop(fd);                                          
  rtems_libio_check_is_open(iop);                                     
a000e40c:	eb000b33 	bl	a00110e0 <__errno>                             
a000e410:	e3a03009 	mov	r3, #9                                        
a000e414:	e5803000 	str	r3, [r0]                                      
a000e418:	e3e05000 	mvn	r5, #0                                        
a000e41c:	eafffff8 	b	a000e404 <close+0x54>                           
                                                                      

a00062a4 <ctermid>: static char *ctermid_name = "/dev/console"; char *ctermid( char *s ) {
a00062a4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if ( !s )                                                           
a00062a8:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
    return ctermid_name;                                              
a00062ac:	059f4014 	ldreq	r4, [pc, #20]	; a00062c8 <ctermid+0x24>     <== NOT EXECUTED
                                                                      
char *ctermid(                                                        
  char *s                                                             
)                                                                     
{                                                                     
  if ( !s )                                                           
a00062b0:	0a000002 	beq	a00062c0 <ctermid+0x1c>                       <== NOT EXECUTED
  /*                                                                  
   *  We have no way of knowing the length of the user provided buffer.
   *  It may not be large enough but there is no way to know that. :( 
   *  So this is a potential buffer owerrun that we can do nothing about.
   */                                                                 
  strcpy( s, ctermid_name );                                          
a00062b4:	e59f100c 	ldr	r1, [pc, #12]	; a00062c8 <ctermid+0x24>       <== NOT EXECUTED
a00062b8:	e3a0200d 	mov	r2, #13                                       <== NOT EXECUTED
a00062bc:	eb0025ef 	bl	a000fa80 <memcpy>                              <== NOT EXECUTED
  return s;                                                           
}                                                                     
a00062c0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00062c4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0005cf8 <devFS_Show>: { int i; rtems_filesystem_location_info_t *temp_loc; rtems_device_name_t *device_name_table; temp_loc = &rtems_filesystem_root;
a0005cf8:	e59f3084 	ldr	r3, [pc, #132]	; a0005d84 <devFS_Show+0x8c>   <== NOT EXECUTED
                                                                      
#include <rtems/seterr.h>                                             
#include "devfs.h"                                                    
                                                                      
int devFS_Show(void)                                                  
{                                                                     
a0005cfc:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  int                               i;                                
  rtems_filesystem_location_info_t *temp_loc;                         
  rtems_device_name_t              *device_name_table;                
                                                                      
  temp_loc = &rtems_filesystem_root;                                  
a0005d00:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
  device_name_table = (rtems_device_name_t *)temp_loc->node_access;   
a0005d04:	e5935018 	ldr	r5, [r3, #24]                                 <== NOT EXECUTED
  if (!device_name_table)                                             
a0005d08:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0005d0c:	0a000017 	beq	a0005d70 <devFS_Show+0x78>                    <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++){                      
a0005d10:	e59f6070 	ldr	r6, [pc, #112]	; a0005d88 <devFS_Show+0x90>   <== NOT EXECUTED
a0005d14:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a0005d18:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0005d1c:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0005d20:	11a04003 	movne	r4, r3                                      <== NOT EXECUTED
    if (device_name_table[i].device_name){                            
a0005d24:	13a07014 	movne	r7, #20                                     <== NOT EXECUTED
  temp_loc = &rtems_filesystem_root;                                  
  device_name_table = (rtems_device_name_t *)temp_loc->node_access;   
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++){                      
a0005d28:	0a00000f 	beq	a0005d6c <devFS_Show+0x74>                    <== NOT EXECUTED
    if (device_name_table[i].device_name){                            
a0005d2c:	e0030397 	mul	r3, r7, r3                                    <== NOT EXECUTED
        printk("/%s %d %d\n", device_name_table[i].device_name,       
a0005d30:	e59f0054 	ldr	r0, [pc, #84]	; a0005d8c <devFS_Show+0x94>    <== NOT EXECUTED
  device_name_table = (rtems_device_name_t *)temp_loc->node_access;   
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++){                      
    if (device_name_table[i].device_name){                            
a0005d34:	e7951003 	ldr	r1, [r5, r3]                                  <== NOT EXECUTED
a0005d38:	e0853003 	add	r3, r5, r3                                    <== NOT EXECUTED
a0005d3c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0005d40:	0a000002 	beq	a0005d50 <devFS_Show+0x58>                    <== NOT EXECUTED
        printk("/%s %d %d\n", device_name_table[i].device_name,       
a0005d44:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
a0005d48:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a0005d4c:	eb0004c7 	bl	a0007070 <printk>                              <== NOT EXECUTED
  temp_loc = &rtems_filesystem_root;                                  
  device_name_table = (rtems_device_name_t *)temp_loc->node_access;   
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++){                      
a0005d50:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
a0005d54:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
a0005d58:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0005d5c:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
a0005d60:	3afffff1 	bcc	a0005d2c <devFS_Show+0x34>                    <== NOT EXECUTED
    if (device_name_table[i].device_name){                            
        printk("/%s %d %d\n", device_name_table[i].device_name,       
            device_name_table[i].major, device_name_table[i].minor);  
    }                                                                 
  }                                                                   
  return 0;                                                           
a0005d64:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0005d68:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
a0005d6c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  rtems_device_name_t              *device_name_table;                
                                                                      
  temp_loc = &rtems_filesystem_root;                                  
  device_name_table = (rtems_device_name_t *)temp_loc->node_access;   
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0005d70:	eb0024e7 	bl	a000f114 <__errno>                             <== NOT EXECUTED
a0005d74:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a0005d78:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0005d7c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0005d80:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000ea3c <devFS_close>: #include "devfs.h" int devFS_close( rtems_libio_t *iop ) {
a000ea3c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a000ea40:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  rtems_device_name_t           *np;                                  
                                                                      
  np         = (rtems_device_name_t *)iop->pathinfo.node_access;      
a000ea44:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
#include "devfs.h"                                                    
                                                                      
int devFS_close(                                                      
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a000ea48:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
  rtems_device_name_t           *np;                                  
                                                                      
  np         = (rtems_device_name_t *)iop->pathinfo.node_access;      
                                                                      
  args.iop   = iop;                                                   
  args.flags = 0;                                                     
a000ea4c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  args.mode  = 0;                                                     
                                                                      
  status = rtems_io_close(                                            
a000ea50:	e590100c 	ldr	r1, [r0, #12]                                 <== NOT EXECUTED
a000ea54:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000ea58:	e5900008 	ldr	r0, [r0, #8]                                  <== NOT EXECUTED
  rtems_status_code              status;                              
  rtems_device_name_t           *np;                                  
                                                                      
  np         = (rtems_device_name_t *)iop->pathinfo.node_access;      
                                                                      
  args.iop   = iop;                                                   
a000ea5c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
  args.flags = 0;                                                     
a000ea60:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  args.mode  = 0;                                                     
a000ea64:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  status = rtems_io_close(                                            
a000ea68:	eb000381 	bl	a000f874 <rtems_io_close>                      <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  return rtems_deviceio_errno(status);                                
a000ea6c:	eb000047 	bl	a000eb90 <rtems_deviceio_errno>                <== NOT EXECUTED
}                                                                     
a000ea70:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a000ea74:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000ea78 <devFS_evaluate_path>: const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) {
a000ea78:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
  int                   i;                                            
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* see if 'flags' is valid */                                       
  if ( !rtems_libio_is_valid_perms( flags ) )                         
a000ea7c:	e3d22007 	bics	r2, r2, #7                                   
  const char                        *pathname,                        
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc                          
)                                                                     
{                                                                     
a000ea80:	e24dd004 	sub	sp, sp, #4                                    
a000ea84:	e1a0b000 	mov	fp, r0                                        
a000ea88:	e1a04001 	mov	r4, r1                                        
a000ea8c:	e58d3000 	str	r3, [sp]                                      
  int                   i;                                            
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* see if 'flags' is valid */                                       
  if ( !rtems_libio_is_valid_perms( flags ) )                         
a000ea90:	1a00002d 	bne	a000eb4c <devFS_evaluate_path+0xd4>           
    rtems_set_errno_and_return_minus_one( EPERM );                    
                                                                      
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
a000ea94:	e59d1000 	ldr	r1, [sp]                                      
a000ea98:	e5917000 	ldr	r7, [r1]                                      
  if (!device_name_table)                                             
a000ea9c:	e3570000 	cmp	r7, #0                                        
a000eaa0:	0a00002e 	beq	a000eb60 <devFS_evaluate_path+0xe8>           
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
a000eaa4:	e59f30c8 	ldr	r3, [pc, #200]	; a000eb74 <devFS_evaluate_path+0xfc>
a000eaa8:	e5938000 	ldr	r8, [r3]                                      
a000eaac:	e3580000 	cmp	r8, #0                                        
a000eab0:	11a09002 	movne	r9, r2                                      
a000eab4:	11a05009 	movne	r5, r9                                      
    if (!device_name_table[i].device_name)                            
a000eab8:	13a0a014 	movne	sl, #20                                     
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
a000eabc:	0a000010 	beq	a000eb04 <devFS_evaluate_path+0x8c>           
    if (!device_name_table[i].device_name)                            
a000eac0:	e009099a 	mul	r9, sl, r9                                    
      continue;                                                       
                                                                      
    if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
a000eac4:	e1a0000b 	mov	r0, fp                                        
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
    if (!device_name_table[i].device_name)                            
a000eac8:	e7976009 	ldr	r6, [r7, r9]                                  
      continue;                                                       
                                                                      
    if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
a000eacc:	e1a02004 	mov	r2, r4                                        
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
    if (!device_name_table[i].device_name)                            
a000ead0:	e0879009 	add	r9, r7, r9                                    
a000ead4:	e2561000 	subs	r1, r6, #0                                   
a000ead8:	0a000005 	beq	a000eaf4 <devFS_evaluate_path+0x7c>           
      continue;                                                       
                                                                      
    if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
a000eadc:	eb000a89 	bl	a0011508 <strncmp>                             <== NOT EXECUTED
a000eae0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000eae4:	1a000002 	bne	a000eaf4 <devFS_evaluate_path+0x7c>           <== NOT EXECUTED
      continue;                                                       
                                                                      
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
a000eae8:	e7d60004 	ldrb	r0, [r6, r4]                                 <== NOT EXECUTED
a000eaec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000eaf0:	0a000008 	beq	a000eb18 <devFS_evaluate_path+0xa0>           <== NOT EXECUTED
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (i = 0; i < rtems_device_table_size; i++) {                     
a000eaf4:	e2855001 	add	r5, r5, #1                                    
a000eaf8:	e1580005 	cmp	r8, r5                                        
a000eafc:	e1a09005 	mov	r9, r5                                        
a000eb00:	8affffee 	bhi	a000eac0 <devFS_evaluate_path+0x48>           
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
    return 0;                                                         
  }                                                                   
                                                                      
  /* no such file or directory */                                     
  rtems_set_errno_and_return_minus_one( ENOENT );                     
a000eb04:	eb0006c0 	bl	a001060c <__errno>                             
a000eb08:	e3a03002 	mov	r3, #2                                        
a000eb0c:	e5803000 	str	r3, [r0]                                      
a000eb10:	e3e00000 	mvn	r0, #0                                        
a000eb14:	ea00000a 	b	a000eb44 <devFS_evaluate_path+0xcc>             
                                                                      
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
a000eb18:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
    pathloc->handlers = &devFS_file_handlers;                         
    pathloc->ops = &devFS_ops;                                        
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
a000eb1c:	e59f3054 	ldr	r3, [pc, #84]	; a000eb78 <devFS_evaluate_path+0x100><== NOT EXECUTED
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
    pathloc->handlers = &devFS_file_handlers;                         
a000eb20:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
    pathloc->ops = &devFS_ops;                                        
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
a000eb24:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
                                                                      
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
a000eb28:	e5829000 	str	r9, [r2]                                      <== NOT EXECUTED
    pathloc->handlers = &devFS_file_handlers;                         
a000eb2c:	e59f2048 	ldr	r2, [pc, #72]	; a000eb7c <devFS_evaluate_path+0x104><== NOT EXECUTED
    pathloc->ops = &devFS_ops;                                        
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
a000eb30:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          <== NOT EXECUTED
    if (device_name_table[i].device_name[pathnamelen] != '\0')        
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
    pathloc->handlers = &devFS_file_handlers;                         
a000eb34:	e5812008 	str	r2, [r1, #8]                                  <== NOT EXECUTED
    pathloc->ops = &devFS_ops;                                        
a000eb38:	e59f2040 	ldr	r2, [pc, #64]	; a000eb80 <devFS_evaluate_path+0x108><== NOT EXECUTED
    pathloc->mt_entry = rtems_filesystem_root.mt_entry;               
a000eb3c:	e5813010 	str	r3, [r1, #16]                                 <== NOT EXECUTED
      continue;                                                       
                                                                      
    /* find the device, set proper values */                          
    pathloc->node_access = (void *)&device_name_table[i];             
    pathloc->handlers = &devFS_file_handlers;                         
    pathloc->ops = &devFS_ops;                                        
a000eb40:	e581200c 	str	r2, [r1, #12]                                 <== NOT EXECUTED
    return 0;                                                         
  }                                                                   
                                                                      
  /* no such file or directory */                                     
  rtems_set_errno_and_return_minus_one( ENOENT );                     
}                                                                     
a000eb44:	e28dd004 	add	sp, sp, #4                                    
a000eb48:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
  int                   i;                                            
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* see if 'flags' is valid */                                       
  if ( !rtems_libio_is_valid_perms( flags ) )                         
    rtems_set_errno_and_return_minus_one( EPERM );                    
a000eb4c:	eb0006ae 	bl	a001060c <__errno>                             <== NOT EXECUTED
a000eb50:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000eb54:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000eb58:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000eb5c:	eafffff8 	b	a000eb44 <devFS_evaluate_path+0xcc>             <== NOT EXECUTED
                                                                      
  /* get the device name table */                                     
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a000eb60:	eb0006a9 	bl	a001060c <__errno>                             <== NOT EXECUTED
a000eb64:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a000eb68:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000eb6c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000eb70:	eafffff3 	b	a000eb44 <devFS_evaluate_path+0xcc>             <== NOT EXECUTED
                                                                      

a00072b8 <devFS_initialize>: int devFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry, const void *data ) {
a00072b8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* allocate device only filesystem name table */                    
  device_name_table = (rtems_device_name_t *)_Workspace_Allocate(     
a00072bc:	e59f7058 	ldr	r7, [pc, #88]	; a000731c <devFS_initialize+0x64>
                                                                      
int devFS_initialize(                                                 
  rtems_filesystem_mount_table_entry_t *temp_mt_entry,                
  const void                           *data                          
)                                                                     
{                                                                     
a00072c0:	e1a04000 	mov	r4, r0                                        
  rtems_device_name_t  *device_name_table;                            
                                                                      
  /* allocate device only filesystem name table */                    
  device_name_table = (rtems_device_name_t *)_Workspace_Allocate(     
a00072c4:	e3a06014 	mov	r6, #20                                       
a00072c8:	e5970000 	ldr	r0, [r7]                                      
a00072cc:	e0000096 	mul	r0, r6, r0                                    
a00072d0:	eb001c66 	bl	a000e470 <_Workspace_Allocate>                 
        sizeof( rtems_device_name_t ) * ( rtems_device_table_size )   
        );                                                            
                                                                      
  /* no memory for device filesystem */                               
  if (!device_name_table)                                             
a00072d4:	e2505000 	subs	r5, r0, #0                                   
a00072d8:	0a00000a 	beq	a0007308 <devFS_initialize+0x50>              
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
                                                                      
  memset(                                                             
a00072dc:	e5972000 	ldr	r2, [r7]                                      
a00072e0:	e3a01000 	mov	r1, #0                                        
a00072e4:	e0020296 	mul	r2, r6, r2                                    
a00072e8:	eb002764 	bl	a0011080 <memset>                              
    device_name_table, 0,                                             
    sizeof( rtems_device_name_t ) * ( rtems_device_table_size )       
    );                                                                
                                                                      
  /* set file handlers */                                             
  temp_mt_entry->mt_fs_root.handlers     = &devFS_file_handlers;      
a00072ec:	e59f302c 	ldr	r3, [pc, #44]	; a0007320 <devFS_initialize+0x68>
  temp_mt_entry->mt_fs_root.ops          = &devFS_ops;                
                                                                      
  /* Set the node_access to device name table */                      
  temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;  
a00072f0:	e584501c 	str	r5, [r4, #28]                                 
                                                                      
  return 0;                                                           
a00072f4:	e3a00000 	mov	r0, #0                                        
    sizeof( rtems_device_name_t ) * ( rtems_device_table_size )       
    );                                                                
                                                                      
  /* set file handlers */                                             
  temp_mt_entry->mt_fs_root.handlers     = &devFS_file_handlers;      
  temp_mt_entry->mt_fs_root.ops          = &devFS_ops;                
a00072f8:	e2832038 	add	r2, r3, #56	; 0x38                            
    device_name_table, 0,                                             
    sizeof( rtems_device_name_t ) * ( rtems_device_table_size )       
    );                                                                
                                                                      
  /* set file handlers */                                             
  temp_mt_entry->mt_fs_root.handlers     = &devFS_file_handlers;      
a00072fc:	e5843024 	str	r3, [r4, #36]	; 0x24                          
  temp_mt_entry->mt_fs_root.ops          = &devFS_ops;                
a0007300:	e5842028 	str	r2, [r4, #40]	; 0x28                          
                                                                      
  /* Set the node_access to device name table */                      
  temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;  
                                                                      
  return 0;                                                           
}                                                                     
a0007304:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
        sizeof( rtems_device_name_t ) * ( rtems_device_table_size )   
        );                                                            
                                                                      
  /* no memory for device filesystem */                               
  if (!device_name_table)                                             
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
a0007308:	eb0024bf 	bl	a001060c <__errno>                             <== NOT EXECUTED
a000730c:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0007310:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007314:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007318:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a00074a0 <devFS_ioctl>: int devFS_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) {
a00074a0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_ioctl_args_t  args;                                     
  rtems_status_code         status;                                   
  rtems_device_name_t      *np;                                       
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
a00074a4:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
int devFS_ioctl(                                                      
  rtems_libio_t *iop,                                                 
  uint32_t       command,                                             
  void          *buffer                                               
)                                                                     
{                                                                     
a00074a8:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
a00074ac:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_name_t      *np;                                       
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop     = iop;                                                 
  args.command = command;                                             
a00074b0:	e98d0006 	stmib	sp, {r1, r2}                                <== NOT EXECUTED
  args.buffer  = buffer;                                              
                                                                      
  status = rtems_io_control(                                          
a00074b4:	e59c0008 	ldr	r0, [ip, #8]                                  <== NOT EXECUTED
a00074b8:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
a00074bc:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  rtems_status_code         status;                                   
  rtems_device_name_t      *np;                                       
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop     = iop;                                                 
a00074c0:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.command = command;                                             
  args.buffer  = buffer;                                              
                                                                      
  status = rtems_io_control(                                          
a00074c4:	eb00103d 	bl	a000b5c0 <rtems_io_control>                    <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00074c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return args.ioctl_return;                                           
a00074cc:	059d000c 	ldreq	r0, [sp, #12]                               <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00074d0:	1a000001 	bne	a00074dc <devFS_ioctl+0x3c>                   <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return args.ioctl_return;                                           
}                                                                     
a00074d4:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a00074d8:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a00074dc:	eb001dab 	bl	a000eb90 <rtems_deviceio_errno>                <== NOT EXECUTED
a00074e0:	eafffffb 	b	a00074d4 <devFS_ioctl+0x34>                     <== NOT EXECUTED
                                                                      

a0007324 <devFS_mknod>: const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) {
a0007324:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
a0007328:	e1a04000 	mov	r4, r0                                        
   * condition and do not create the '/dev' and the 'path'            
   * actually passed in is 'dev', not '/dev'. Just return 0 to        
   * indicate we are OK.                                              
   */                                                                 
                                                                      
  if ((path[0] == 'd') && (path[1] == 'e') &&                         
a000732c:	e5d00000 	ldrb	r0, [r0]                                     
  const char                        *path,                            
  mode_t                             mode,                            
  dev_t                              dev,                             
  rtems_filesystem_location_info_t  *pathloc                          
)                                                                     
{                                                                     
a0007330:	e24dd004 	sub	sp, sp, #4                                    
a0007334:	e1a05001 	mov	r5, r1                                        
   * condition and do not create the '/dev' and the 'path'            
   * actually passed in is 'dev', not '/dev'. Just return 0 to        
   * indicate we are OK.                                              
   */                                                                 
                                                                      
  if ((path[0] == 'd') && (path[1] == 'e') &&                         
a0007338:	e3500064 	cmp	r0, #100	; 0x64                               
  const char                        *path,                            
  mode_t                             mode,                            
  dev_t                              dev,                             
  rtems_filesystem_location_info_t  *pathloc                          
)                                                                     
{                                                                     
a000733c:	e58d2000 	str	r2, [sp]                                      
a0007340:	e1a0b003 	mov	fp, r3                                        
   * condition and do not create the '/dev' and the 'path'            
   * actually passed in is 'dev', not '/dev'. Just return 0 to        
   * indicate we are OK.                                              
   */                                                                 
                                                                      
  if ((path[0] == 'd') && (path[1] == 'e') &&                         
a0007344:	0a000039 	beq	a0007430 <devFS_mknod+0x10c>                  
      (path[2] == 'v') && (path[3] == '\0'))                          
      return 0;                                                       
                                                                      
  /* must be a character device or a block device */                  
  if (!S_ISBLK(mode) && !S_ISCHR(mode))                               
a0007348:	e2053a0f 	and	r3, r5, #61440	; 0xf000                       
a000734c:	e3530a02 	cmp	r3, #8192	; 0x2000                            
a0007350:	13530a06 	cmpne	r3, #24576	; 0x6000                         
a0007354:	03a03000 	moveq	r3, #0                                      
a0007358:	13a03001 	movne	r3, #1                                      
a000735c:	1a00003d 	bne	a0007458 <devFS_mknod+0x134>                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  else                                                                
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
  /* Find an empty slot in device name table */                       
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
a0007360:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          
a0007364:	e5927000 	ldr	r7, [r2]                                      
  if (!device_name_table)                                             
a0007368:	e3570000 	cmp	r7, #0                                        
a000736c:	0a000043 	beq	a0007480 <devFS_mknod+0x15c>                  
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
a0007370:	e59f211c 	ldr	r2, [pc, #284]	; a0007494 <devFS_mknod+0x170> 
a0007374:	e5928000 	ldr	r8, [r2]                                      
a0007378:	e3580000 	cmp	r8, #0                                        
a000737c:	13e09000 	mvnne	r9, #0                                      
a0007380:	11a06003 	movne	r6, r3                                      
      if (device_name_table[i].device_name == NULL)                   
a0007384:	13a0a014 	movne	sl, #20                                     
  /* Find an empty slot in device name table */                       
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
a0007388:	1a000007 	bne	a00073ac <devFS_mknod+0x88>                   
a000738c:	ea000036 	b	a000746c <devFS_mknod+0x148>                    <== NOT EXECUTED
      if (device_name_table[i].device_name == NULL)                   
          slot = i;                                                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
a0007390:	eb0027b8 	bl	a0011278 <strcmp>                              
a0007394:	e3500000 	cmp	r0, #0                                        
a0007398:	0a00001f 	beq	a000741c <devFS_mknod+0xf8>                   
  /* Find an empty slot in device name table */                       
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
a000739c:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
a00073a0:	e1560008 	cmp	r6, r8                                        <== NOT EXECUTED
a00073a4:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a00073a8:	2a000009 	bcs	a00073d4 <devFS_mknod+0xb0>                   <== NOT EXECUTED
      if (device_name_table[i].device_name == NULL)                   
a00073ac:	e003039a 	mul	r3, sl, r3                                    
          slot = i;                                                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
a00073b0:	e1a00004 	mov	r0, r4                                        
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
      if (device_name_table[i].device_name == NULL)                   
a00073b4:	e7973003 	ldr	r3, [r7, r3]                                  
a00073b8:	e2531000 	subs	r1, r3, #0                                   
a00073bc:	1afffff3 	bne	a0007390 <devFS_mknod+0x6c>                   
a00073c0:	e1a09006 	mov	r9, r6                                        
  /* Find an empty slot in device name table */                       
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
a00073c4:	e2866001 	add	r6, r6, #1                                    
a00073c8:	e1560008 	cmp	r6, r8                                        
a00073cc:	e1a03006 	mov	r3, r6                                        
a00073d0:	3afffff5 	bcc	a00073ac <devFS_mknod+0x88>                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
              rtems_set_errno_and_return_minus_one( EEXIST );         
  }                                                                   
                                                                      
  if (slot == -1)                                                     
a00073d4:	e3790001 	cmn	r9, #1                                        
a00073d8:	0a000023 	beq	a000746c <devFS_mknod+0x148>                  
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a00073dc:	e10f6000 	mrs	r6, CPSR                                      
a00073e0:	e3863080 	orr	r3, r6, #128	; 0x80                           
a00073e4:	e129f003 	msr	CPSR_fc, r3                                   
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
                                                                      
  _ISR_Disable(level);                                                
  device_name_table[slot].device_name  = (char *)path;                
a00073e8:	e3a03014 	mov	r3, #20                                       
a00073ec:	e0090993 	mul	r9, r3, r9                                    
  device_name_table[slot].device_name_length = strlen(path);          
a00073f0:	e1a00004 	mov	r0, r4                                        
                                                                      
  if (slot == -1)                                                     
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
                                                                      
  _ISR_Disable(level);                                                
  device_name_table[slot].device_name  = (char *)path;                
a00073f4:	e7874009 	str	r4, [r7, r9]                                  
  device_name_table[slot].device_name_length = strlen(path);          
a00073f8:	eb00282a 	bl	a00114a8 <strlen>                              
  device_name_table[slot].major = major;                              
a00073fc:	e59d3000 	ldr	r3, [sp]                                      
                                                                      
  if (slot == -1)                                                     
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
                                                                      
  _ISR_Disable(level);                                                
  device_name_table[slot].device_name  = (char *)path;                
a0007400:	e0877009 	add	r7, r7, r9                                    
  device_name_table[slot].device_name_length = strlen(path);          
a0007404:	e9870809 	stmib	r7, {r0, r3, fp}                            
  device_name_table[slot].major = major;                              
  device_name_table[slot].minor = minor;                              
  device_name_table[slot].mode  = mode;                               
a0007408:	e5875010 	str	r5, [r7, #16]                                 
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000740c:	e129f006 	msr	CPSR_fc, r6                                   
  _ISR_Enable(level);                                                 
                                                                      
  return 0;                                                           
a0007410:	e3a00000 	mov	r0, #0                                        
}                                                                     
a0007414:	e28dd004 	add	sp, sp, #4                                    
a0007418:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
  for (slot = -1, i = 0; i < rtems_device_table_size; i++){           
      if (device_name_table[i].device_name == NULL)                   
          slot = i;                                                   
      else                                                            
          if (strcmp(path, device_name_table[i].device_name) == 0)    
              rtems_set_errno_and_return_minus_one( EEXIST );         
a000741c:	eb00247a 	bl	a001060c <__errno>                             
a0007420:	e3a03011 	mov	r3, #17                                       
a0007424:	e5803000 	str	r3, [r0]                                      
a0007428:	e3e00000 	mvn	r0, #0                                        
a000742c:	eafffff8 	b	a0007414 <devFS_mknod+0xf0>                     
   * condition and do not create the '/dev' and the 'path'            
   * actually passed in is 'dev', not '/dev'. Just return 0 to        
   * indicate we are OK.                                              
   */                                                                 
                                                                      
  if ((path[0] == 'd') && (path[1] == 'e') &&                         
a0007430:	e5d43001 	ldrb	r3, [r4, #1]                                 
a0007434:	e3530065 	cmp	r3, #101	; 0x65                               
a0007438:	1affffc2 	bne	a0007348 <devFS_mknod+0x24>                   
a000743c:	e5d43002 	ldrb	r3, [r4, #2]                                 
a0007440:	e3530076 	cmp	r3, #118	; 0x76                               
a0007444:	1affffbf 	bne	a0007348 <devFS_mknod+0x24>                   
      (path[2] == 'v') && (path[3] == '\0'))                          
a0007448:	e5d40003 	ldrb	r0, [r4, #3]                                 
a000744c:	e3500000 	cmp	r0, #0                                        
a0007450:	1affffbc 	bne	a0007348 <devFS_mknod+0x24>                   
a0007454:	eaffffee 	b	a0007414 <devFS_mknod+0xf0>                     
      return 0;                                                       
                                                                      
  /* must be a character device or a block device */                  
  if (!S_ISBLK(mode) && !S_ISCHR(mode))                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0007458:	eb00246b 	bl	a001060c <__errno>                             <== NOT EXECUTED
a000745c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007460:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007464:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007468:	eaffffe9 	b	a0007414 <devFS_mknod+0xf0>                     <== NOT EXECUTED
          if (strcmp(path, device_name_table[i].device_name) == 0)    
              rtems_set_errno_and_return_minus_one( EEXIST );         
  }                                                                   
                                                                      
  if (slot == -1)                                                     
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
a000746c:	eb002466 	bl	a001060c <__errno>                             <== NOT EXECUTED
a0007470:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0007474:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007478:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000747c:	eaffffe4 	b	a0007414 <devFS_mknod+0xf0>                     <== NOT EXECUTED
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
  /* Find an empty slot in device name table */                       
  device_name_table = (rtems_device_name_t *)pathloc->node_access;    
  if (!device_name_table)                                             
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0007480:	eb002461 	bl	a001060c <__errno>                             <== NOT EXECUTED
a0007484:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a0007488:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000748c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007490:	eaffffdf 	b	a0007414 <devFS_mknod+0xf0>                     <== NOT EXECUTED
                                                                      

a0007498 <devFS_node_type>: /* * There is only one type of node: device */ return RTEMS_FILESYSTEM_DEVICE; }
a0007498:	e3a00002 	mov	r0, #2                                        <== NOT EXECUTED
a000749c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00074e4 <devFS_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
a00074e4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00074e8:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  rtems_device_name_t           *np;                                  
                                                                      
  np         = (rtems_device_name_t *)iop->pathinfo.node_access;      
a00074ec:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
a00074f0:	e59ce014 	ldr	lr, [ip, #20]                                 <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  const char    *pathname,                                            
  uint32_t       flag,                                                
  uint32_t       mode                                                 
)                                                                     
{                                                                     
a00074f4:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
                                                                      
  status = rtems_io_open(                                             
a00074f8:	e590100c 	ldr	r1, [r0, #12]                                 <== NOT EXECUTED
a00074fc:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0007500:	e5900008 	ldr	r0, [r0, #8]                                  <== NOT EXECUTED
  rtems_status_code              status;                              
  rtems_device_name_t           *np;                                  
                                                                      
  np         = (rtems_device_name_t *)iop->pathinfo.node_access;      
                                                                      
  args.iop   = iop;                                                   
a0007504:	e88d5000 	stm	sp, {ip, lr}                                  <== NOT EXECUTED
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
a0007508:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  status = rtems_io_open(                                             
a000750c:	eb001079 	bl	a000b6f8 <rtems_io_open>                       <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  return rtems_deviceio_errno(status);                                
a0007510:	eb001d9e 	bl	a000eb90 <rtems_deviceio_errno>                <== NOT EXECUTED
}                                                                     
a0007514:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a0007518:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000751c <devFS_read>: ssize_t devFS_read( rtems_libio_t *iop, void *buffer, size_t count ) {
a000751c:	e92d4800 	push	{fp, lr}                                     <== NOT EXECUTED
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
a0007520:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a0007524:	e590e014 	ldr	lr, [r0, #20]                                 <== NOT EXECUTED
ssize_t devFS_read(                                                   
  rtems_libio_t *iop,                                                 
  void          *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a0007528:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a000752c:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
a0007530:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
a0007534:	e59c0008 	ldr	r0, [ip, #8]                                  <== NOT EXECUTED
a0007538:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
a000753c:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a0007540:	e283c00c 	add	ip, r3, #12                                   <== NOT EXECUTED
a0007544:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  rtems_status_code       status;                                     
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
                                                                      
  args.iop         = iop;                                             
a0007548:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
a000754c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
a0007550:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  rtems_device_name_t     *np;                                        
                                                                      
  np               = (rtems_device_name_t *)iop->pathinfo.node_access;
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a0007554:	e98d1800 	stmib	sp, {fp, ip}                                <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a0007558:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
a000755c:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  status = rtems_io_read(                                             
a0007560:	eb001079 	bl	a000b74c <rtems_io_read>                       <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a0007564:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
a0007568:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a000756c:	1a000001 	bne	a0007578 <devFS_read+0x5c>                    <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
a0007570:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a0007574:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a0007578:	eb001d84 	bl	a000eb90 <rtems_deviceio_errno>                <== NOT EXECUTED
a000757c:	eafffffb 	b	a0007570 <devFS_read+0x54>                      <== NOT EXECUTED
                                                                      

a0007580 <devFS_stat>: struct stat *buf ) { rtems_device_name_t *the_dev; the_dev = (rtems_device_name_t *)loc->node_access;
a0007580:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  #endif                                                              
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
  buf->st_mode = the_dev->mode;                                       
  return 0;                                                           
}                                                                     
a0007584:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if (!the_dev)                                                     
      rtems_set_errno_and_return_minus_one( EFAULT );                 
  #endif                                                              
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
a0007588:	e593c00c 	ldr	ip, [r3, #12]                                 <== NOT EXECUTED
  rtems_device_minor_number _minor                                    
)                                                                     
{                                                                     
  union __rtems_dev_t temp;                                           
                                                                      
  temp.__overlay.major = _major;                                      
a000758c:	e5932008 	ldr	r2, [r3, #8]                                  <== NOT EXECUTED
  buf->st_mode = the_dev->mode;                                       
a0007590:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if (!the_dev)                                                     
      rtems_set_errno_and_return_minus_one( EFAULT );                 
  #endif                                                              
                                                                      
  buf->st_rdev  = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
a0007594:	e581c01c 	str	ip, [r1, #28]                                 <== NOT EXECUTED
a0007598:	e5812018 	str	r2, [r1, #24]                                 <== NOT EXECUTED
  buf->st_mode = the_dev->mode;                                       
a000759c:	e581300c 	str	r3, [r1, #12]                                 <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a00075a0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00075a4 <devFS_write>: ssize_t devFS_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
a00075a4:	e92d4800 	push	{fp, lr}                                     <== NOT EXECUTED
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  rtems_device_name_t    *np;                                         
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
a00075a8:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a00075ac:	e590e014 	ldr	lr, [r0, #20]                                 <== NOT EXECUTED
ssize_t devFS_write(                                                  
  rtems_libio_t *iop,                                                 
  const void    *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a00075b0:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a00075b4:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
a00075b8:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write(                                            
a00075bc:	e59c0008 	ldr	r0, [ip, #8]                                  <== NOT EXECUTED
a00075c0:	e59c100c 	ldr	r1, [ip, #12]                                 <== NOT EXECUTED
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
a00075c4:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  rtems_device_name_t    *np;                                         
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a00075c8:	e283c00c 	add	ip, r3, #12                                   <== NOT EXECUTED
a00075cc:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  rtems_status_code       status;                                     
  rtems_device_name_t    *np;                                         
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop         = iop;                                             
a00075d0:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write(                                            
a00075d4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
a00075d8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  rtems_device_name_t    *np;                                         
                                                                      
  np           = (rtems_device_name_t *)iop->pathinfo.node_access;    
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a00075dc:	e98d1800 	stmib	sp, {fp, ip}                                <== NOT EXECUTED
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a00075e0:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
a00075e4:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  status = rtems_io_write(                                            
a00075e8:	eb00106c 	bl	a000b7a0 <rtems_io_write>                      <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00075ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
a00075f0:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    np->major,                                                        
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00075f4:	1a000001 	bne	a0007600 <devFS_write+0x5c>                   <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
a00075f8:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a00075fc:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
    np->minor,                                                        
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a0007600:	eb001d62 	bl	a000eb90 <rtems_deviceio_errno>                <== NOT EXECUTED
a0007604:	eafffffb 	b	a00075f8 <devFS_write+0x54>                     <== NOT EXECUTED
                                                                      

a00106a0 <device_close>: */ int device_close( rtems_libio_t *iop ) {
a00106a0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a00106a4:	e5904018 	ldr	r4, [r0, #24]                                 <== NOT EXECUTED
 */                                                                   
                                                                      
int device_close(                                                     
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a00106a8:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a00106ac:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop   = iop;                                                   
  args.flags = 0;                                                     
a00106b0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  args.mode  = 0;                                                     
                                                                      
  status = rtems_io_close(                                            
a00106b4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a00106b8:	e5941054 	ldr	r1, [r4, #84]	; 0x54                          <== NOT EXECUTED
a00106bc:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop   = iop;                                                   
a00106c0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
  args.flags = 0;                                                     
a00106c4:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  args.mode  = 0;                                                     
a00106c8:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  status = rtems_io_close(                                            
a00106cc:	eb0001c0 	bl	a0010dd4 <rtems_io_close>                      <== NOT EXECUTED
a00106d0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  IMFS_check_node_remove( the_jnode );                                
a00106d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00106d8:	ebfff6d6 	bl	a000e238 <IMFS_check_node_remove>              <== NOT EXECUTED
                                                                      
  return rtems_deviceio_errno( status );                              
a00106dc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00106e0:	eb00026b 	bl	a0011094 <rtems_deviceio_errno>                <== NOT EXECUTED
}                                                                     
a00106e4:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a00106e8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0010804 <device_ftruncate>: rtems_libio_t *iop, rtems_off64_t length ) { return 0; }
a0010804:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010808:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00107b4 <device_ioctl>: int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) {
a00107b4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  args.iop     = iop;                                                 
  args.command = command;                                             
  args.buffer  = buffer;                                              
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a00107b8:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
int device_ioctl(                                                     
  rtems_libio_t *iop,                                                 
  uint32_t       command,                                             
  void          *buffer                                               
)                                                                     
{                                                                     
a00107bc:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
a00107c0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_libio_ioctl_args_t  args;                                     
  rtems_status_code         status;                                   
  IMFS_jnode_t             *the_jnode;                                
                                                                      
  args.iop     = iop;                                                 
  args.command = command;                                             
a00107c4:	e98d0006 	stmib	sp, {r1, r2}                                <== NOT EXECUTED
  args.buffer  = buffer;                                              
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  status = rtems_io_control(                                          
a00107c8:	e59c0050 	ldr	r0, [ip, #80]	; 0x50                          <== NOT EXECUTED
a00107cc:	e59c1054 	ldr	r1, [ip, #84]	; 0x54                          <== NOT EXECUTED
a00107d0:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
{                                                                     
  rtems_libio_ioctl_args_t  args;                                     
  rtems_status_code         status;                                   
  IMFS_jnode_t             *the_jnode;                                
                                                                      
  args.iop     = iop;                                                 
a00107d4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.command = command;                                             
  args.buffer  = buffer;                                              
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  status = rtems_io_control(                                          
a00107d8:	eb000192 	bl	a0010e28 <rtems_io_control>                    <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00107dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return args.ioctl_return;                                           
a00107e0:	059d000c 	ldreq	r0, [sp, #12]                               <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00107e4:	1a000001 	bne	a00107f0 <device_ioctl+0x3c>                  <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return args.ioctl_return;                                           
}                                                                     
a00107e8:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a00107ec:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a00107f0:	eb000227 	bl	a0011094 <rtems_deviceio_errno>                <== NOT EXECUTED
a00107f4:	eafffffb 	b	a00107e8 <device_ioctl+0x34>                    <== NOT EXECUTED
                                                                      

a00107f8 <device_lseek>: rtems_off64_t offset, int whence ) { return offset; }
a00107f8:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a00107fc:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0010800:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010668 <device_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
a0010668:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a001066c:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
  rtems_libio_open_close_args_t  args;                                
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode  = iop->pathinfo.node_access;                             
a0010670:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
a0010674:	e59ce014 	ldr	lr, [ip, #20]                                 <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  const char    *pathname,                                            
  uint32_t       flag,                                                
  uint32_t       mode                                                 
)                                                                     
{                                                                     
a0010678:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
                                                                      
  args.iop   = iop;                                                   
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
                                                                      
  status = rtems_io_open(                                             
a001067c:	e5901054 	ldr	r1, [r0, #84]	; 0x54                          <== NOT EXECUTED
a0010680:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0010684:	e5900050 	ldr	r0, [r0, #80]	; 0x50                          <== NOT EXECUTED
  rtems_status_code              status;                              
  IMFS_jnode_t                  *the_jnode;                           
                                                                      
  the_jnode  = iop->pathinfo.node_access;                             
                                                                      
  args.iop   = iop;                                                   
a0010688:	e88d5000 	stm	sp, {ip, lr}                                  <== NOT EXECUTED
  args.flags = iop->flags;                                            
  args.mode  = mode;                                                  
a001068c:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  status = rtems_io_open(                                             
a0010690:	eb0001f9 	bl	a0010e7c <rtems_io_open>                       <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  return rtems_deviceio_errno( status );                              
a0010694:	eb00027e 	bl	a0011094 <rtems_deviceio_errno>                <== NOT EXECUTED
}                                                                     
a0010698:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a001069c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a00106ec <device_read>: ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) {
a00106ec:	e92d4800 	push	{fp, lr}                                     <== NOT EXECUTED
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a00106f0:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a00106f4:	e590e014 	ldr	lr, [r0, #20]                                 <== NOT EXECUTED
ssize_t device_read(                                                  
  rtems_libio_t *iop,                                                 
  void          *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a00106f8:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a00106fc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
a0010700:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
a0010704:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
a0010708:	e59c0050 	ldr	r0, [ip, #80]	; 0x50                          <== NOT EXECUTED
a001070c:	e59c1054 	ldr	r1, [ip, #84]	; 0x54                          <== NOT EXECUTED
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
a0010710:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.offset      = iop->offset;                                     
a0010714:	e283c00c 	add	ip, r3, #12                                   <== NOT EXECUTED
a0010718:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_read(                                             
a001071c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
a0010720:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a0010724:	e98d1800 	stmib	sp, {fp, ip}                                <== NOT EXECUTED
  args.buffer      = buffer;                                          
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a0010728:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
a001072c:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  status = rtems_io_read(                                             
a0010730:	eb0001e6 	bl	a0010ed0 <rtems_io_read>                       <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a0010734:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
a0010738:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a001073c:	1a000001 	bne	a0010748 <device_read+0x5c>                   <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
a0010740:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a0010744:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a0010748:	eb000251 	bl	a0011094 <rtems_deviceio_errno>                <== NOT EXECUTED
a001074c:	eafffffb 	b	a0010740 <device_read+0x54>                     <== NOT EXECUTED
                                                                      

a0010750 <device_write>: ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
a0010750:	e92d4800 	push	{fp, lr}                                     <== NOT EXECUTED
  rtems_libio_rw_args_t   args;                                       
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a0010754:	e590c018 	ldr	ip, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a0010758:	e590e014 	ldr	lr, [r0, #20]                                 <== NOT EXECUTED
ssize_t device_write(                                                 
  rtems_libio_t *iop,                                                 
  const void    *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a001075c:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a0010760:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
a0010764:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
  args.count       = count;                                           
a0010768:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write(                                            
a001076c:	e59c0050 	ldr	r0, [ip, #80]	; 0x50                          <== NOT EXECUTED
a0010770:	e59c1054 	ldr	r1, [ip, #84]	; 0x54                          <== NOT EXECUTED
  rtems_status_code       status;                                     
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
a0010774:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  args.offset      = iop->offset;                                     
a0010778:	e283c00c 	add	ip, r3, #12                                   <== NOT EXECUTED
a001077c:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
                                                                      
  status = rtems_io_write(                                            
a0010780:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
  args.bytes_moved = 0;                                               
a0010784:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  IMFS_jnode_t           *the_jnode;                                  
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  args.iop         = iop;                                             
  args.offset      = iop->offset;                                     
a0010788:	e98d1800 	stmib	sp, {fp, ip}                                <== NOT EXECUTED
  args.buffer      = (void *) buffer;                                 
  args.count       = count;                                           
  args.flags       = iop->flags;                                      
a001078c:	e58de014 	str	lr, [sp, #20]                                 <== NOT EXECUTED
  args.bytes_moved = 0;                                               
a0010790:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
                                                                      
  status = rtems_io_write(                                            
a0010794:	eb0001e2 	bl	a0010f24 <rtems_io_write>                      <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a0010798:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
a001079c:	059d0018 	ldreq	r0, [sp, #24]                               <== NOT EXECUTED
    the_jnode->info.device.major,                                     
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
a00107a0:	1a000001 	bne	a00107ac <device_write+0x5c>                  <== NOT EXECUTED
    return rtems_deviceio_errno(status);                              
                                                                      
  return (ssize_t) args.bytes_moved;                                  
}                                                                     
a00107a4:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a00107a8:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
    the_jnode->info.device.minor,                                     
    (void *) &args                                                    
  );                                                                  
                                                                      
  if ( status )                                                       
    return rtems_deviceio_errno(status);                              
a00107ac:	eb000238 	bl	a0011094 <rtems_deviceio_errno>                <== NOT EXECUTED
a00107b0:	eafffffb 	b	a00107a4 <device_write+0x54>                    <== NOT EXECUTED
                                                                      

a0007318 <drainOutput>: drainOutput (struct rtems_termios_tty *tty) { rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
a0007318:	e59030b4 	ldr	r3, [r0, #180]	; 0xb4                         <== NOT EXECUTED
/*                                                                    
 * Drain output queue                                                 
 */                                                                   
static void                                                           
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
a000731c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
a0007320:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
/*                                                                    
 * Drain output queue                                                 
 */                                                                   
static void                                                           
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
a0007324:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
a0007328:	0a000017 	beq	a000738c <drainOutput+0x74>                   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000732c:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0007330:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0007334:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
    rtems_interrupt_disable (level);                                  
    while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {              
a0007338:	e5901084 	ldr	r1, [r0, #132]	; 0x84                         <== NOT EXECUTED
a000733c:	e5902080 	ldr	r2, [r0, #128]	; 0x80                         <== NOT EXECUTED
a0007340:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a0007344:	0a00000f 	beq	a0007388 <drainOutput+0x70>                   <== NOT EXECUTED
      tty->rawOutBufState = rob_wait;                                 
a0007348:	e3a05002 	mov	r5, #2                                        <== NOT EXECUTED
a000734c:	e5845094 	str	r5, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0007350:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
a0007354:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0007358:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
a000735c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0007360:	eb0009c1 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
a0007364:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007368:	1a000008 	bne	a0007390 <drainOutput+0x78>                   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000736c:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0007370:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0007374:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
    rtems_interrupt_disable (level);                                  
    while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {              
a0007378:	e5941084 	ldr	r1, [r4, #132]	; 0x84                         <== NOT EXECUTED
a000737c:	e5942080 	ldr	r2, [r4, #128]	; 0x80                         <== NOT EXECUTED
a0007380:	e1510002 	cmp	r1, r2                                        <== NOT EXECUTED
a0007384:	1afffff0 	bne	a000734c <drainOutput+0x34>                   <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0007388:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
a000738c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
      tty->rawOutBufState = rob_wait;                                 
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
a0007390:	eb000b5c 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0006ba4 <dup>: int dup( int fildes ) { return fcntl( fildes, F_DUPFD, 0 );
a0006ba4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0006ba8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0006bac:	ea000055 	b	a0006d08 <fcntl>                                <== NOT EXECUTED
                                                                      

a0006b50 <dup2>: int dup2( int fildes, int fildes2 ) {
a0006b50:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0006b54:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0006b58:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
a0006b5c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
                                                                      
int dup2(                                                             
  int fildes,                                                         
  int fildes2                                                         
)                                                                     
{                                                                     
a0006b60:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
a0006b64:	eb00017b 	bl	a0007158 <fstat>                               <== NOT EXECUTED
  if ( status == -1 )                                                 
a0006b68:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
a0006b6c:	e1a0400d 	mov	r4, sp                                        <== NOT EXECUTED
  if ( status == -1 )                                                 
a0006b70:	1a000001 	bne	a0006b7c <dup2+0x2c>                          <== NOT EXECUTED
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
}                                                                     
a0006b74:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0006b78:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
a0006b7c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0006b80:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0006b84:	eb000173 	bl	a0007158 <fstat>                               <== NOT EXECUTED
  if ( status == -1 )                                                 
a0006b88:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006b8c:	0afffff8 	beq	a0006b74 <dup2+0x24>                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
a0006b90:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006b94:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0006b98:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006b9c:	eb000059 	bl	a0006d08 <fcntl>                               <== NOT EXECUTED
a0006ba0:	eafffff3 	b	a0006b74 <dup2+0x24>                            <== NOT EXECUTED
                                                                      

a0008070 <echo>: /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) {
a0008070:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
a0008074:	e591203c 	ldr	r2, [r1, #60]	; 0x3c                          <== NOT EXECUTED
/*                                                                    
 * Echo a typed character                                             
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
a0008078:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000807c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
a0008080:	e3120c02 	tst	r2, #512	; 0x200                              <== NOT EXECUTED
a0008084:	0a00000b 	beq	a00080b8 <echo+0x48>                          <== NOT EXECUTED
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
a0008088:	e59f3070 	ldr	r3, [pc, #112]	; a0008100 <echo+0x90>         <== NOT EXECUTED
a000808c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0008090:	e0833000 	add	r3, r3, r0                                    <== NOT EXECUTED
a0008094:	e5d33001 	ldrb	r3, [r3, #1]                                 <== NOT EXECUTED
 * Echo a typed character                                             
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
a0008098:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a000809c:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a00080a0:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
a00080a4:	e3500009 	cmp	r0, #9                                        <== NOT EXECUTED
a00080a8:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a00080ac:	12033001 	andne	r3, r3, #1                                  <== NOT EXECUTED
a00080b0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00080b4:	1a000003 	bne	a00080c8 <echo+0x58>                          <== NOT EXECUTED
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
    rtems_termios_puts (echobuf, 2, tty);                             
    tty->column += 2;                                                 
  } else {                                                            
    oproc (c, tty);                                                   
a00080b8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00080bc:	ebffff8f 	bl	a0007f00 <oproc>                               <== NOT EXECUTED
  }                                                                   
}                                                                     
a00080c0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00080c4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
a00080c8:	e350000a 	cmp	r0, #10                                       <== NOT EXECUTED
a00080cc:	0afffff9 	beq	a00080b8 <echo+0x48>                          <== NOT EXECUTED
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
a00080d0:	e2203040 	eor	r3, r0, #64	; 0x40                            <== NOT EXECUTED
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
a00080d4:	e3a0c05e 	mov	ip, #94	; 0x5e                                <== NOT EXECUTED
    echobuf[1] = c ^ 0x40;                                            
    rtems_termios_puts (echobuf, 2, tty);                             
a00080d8:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a00080dc:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a00080e0:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
a00080e4:	e5cd3001 	strb	r3, [sp, #1]                                 <== NOT EXECUTED
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
a00080e8:	e5cdc000 	strb	ip, [sp]                                     <== NOT EXECUTED
    echobuf[1] = c ^ 0x40;                                            
    rtems_termios_puts (echobuf, 2, tty);                             
a00080ec:	ebffff3d 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
    tty->column += 2;                                                 
a00080f0:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a00080f4:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
a00080f8:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
 */                                                                   
static void                                                           
echo (unsigned char c, struct rtems_termios_tty *tty)                 
{                                                                     
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
a00080fc:	eaffffef 	b	a00080c0 <echo+0x50>                            <== NOT EXECUTED
                                                                      

a00074c8 <endgrent>: void endgrent(void) { if (group_fp != NULL)
a00074c8:	e59f300c 	ldr	r3, [pc, #12]	; a00074dc <endgrent+0x14>      <== NOT EXECUTED
a00074cc:	e59301c4 	ldr	r0, [r3, #452]	; 0x1c4                        <== NOT EXECUTED
a00074d0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00074d4:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    fclose(group_fp);                                                 
a00074d8:	ea002b5a 	b	a0012248 <fclose>                               <== NOT EXECUTED
                                                                      

a0007354 <endpwent>: void endpwent(void) { if (passwd_fp != NULL)
a0007354:	e59f300c 	ldr	r3, [pc, #12]	; a0007368 <endpwent+0x14>      <== NOT EXECUTED
a0007358:	e59300e8 	ldr	r0, [r3, #232]	; 0xe8                         <== NOT EXECUTED
a000735c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007360:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    fclose(passwd_fp);                                                
a0007364:	ea002bb7 	b	a0012248 <fclose>                               <== NOT EXECUTED
                                                                      

a0008104 <erase>: * FIXME: Some of the tests should check for IEXTEN, too. */ static void erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0)
a0008104:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
 * FIXME: Needs support for WERASE and ECHOPRT.                       
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
a0008108:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  if (tty->ccount == 0)                                               
a000810c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
 * FIXME: Needs support for WERASE and ECHOPRT.                       
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
a0008110:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0008114:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  if (tty->ccount == 0)                                               
a0008118:	0a00000d 	beq	a0008154 <erase+0x50>                         <== NOT EXECUTED
    return;                                                           
  if (lineFlag) {                                                     
a000811c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0008120:	0a00000c 	beq	a0008158 <erase+0x54>                         <== NOT EXECUTED
    if (!(tty->termios.c_lflag & ECHO)) {                             
a0008124:	e590103c 	ldr	r1, [r0, #60]	; 0x3c                          <== NOT EXECUTED
a0008128:	e2112008 	ands	r2, r1, #8                                   <== NOT EXECUTED
a000812c:	0a000052 	beq	a000827c <erase+0x178>                        <== NOT EXECUTED
      tty->ccount = 0;                                                
      return;                                                         
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
a0008130:	e2110010 	ands	r0, r1, #16                                  <== NOT EXECUTED
a0008134:	1a000009 	bne	a0008160 <erase+0x5c>                         <== NOT EXECUTED
      tty->ccount = 0;                                                
a0008138:	e5840020 	str	r0, [r4, #32]                                 <== NOT EXECUTED
      echo (tty->termios.c_cc[VKILL], tty);                           
a000813c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008140:	e5d40044 	ldrb	r0, [r4, #68]	; 0x44                         <== NOT EXECUTED
a0008144:	ebffffc9 	bl	a0008070 <echo>                                <== NOT EXECUTED
      if (tty->termios.c_lflag & ECHOK)                               
a0008148:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
a000814c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a0008150:	1a000068 	bne	a00082f8 <erase+0x1f4>                        <== NOT EXECUTED
a0008154:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
        echo ('\n', tty);                                             
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
a0008158:	e590103c 	ldr	r1, [r0, #60]	; 0x3c                          <== NOT EXECUTED
a000815c:	e2012008 	and	r2, r1, #8                                    <== NOT EXECUTED
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
a0008160:	e59f71a0 	ldr	r7, [pc, #416]	; a0008308 <erase+0x204>       <== NOT EXECUTED
a0008164:	ea000008 	b	a000818c <erase+0x88>                           <== NOT EXECUTED
a0008168:	e3110c02 	tst	r1, #512	; 0x200                              <== NOT EXECUTED
a000816c:	1a000049 	bne	a0008298 <erase+0x194>                        <== NOT EXECUTED
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
a0008170:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0008174:	0afffff6 	beq	a0008154 <erase+0x50>                         <== NOT EXECUTED
        echo ('\n', tty);                                             
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
a0008178:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a000817c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008180:	0a000043 	beq	a0008294 <erase+0x190>                        <== NOT EXECUTED
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
      tty->ccount = 0;                                                
      echo (tty->termios.c_cc[VKILL], tty);                           
      if (tty->termios.c_lflag & ECHOK)                               
        echo ('\n', tty);                                             
a0008184:	e594103c 	ldr	r1, [r4, #60]	; 0x3c                          <== NOT EXECUTED
a0008188:	e2012008 	and	r2, r1, #8                                    <== NOT EXECUTED
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
a000818c:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
a0008190:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0008194:	e5843020 	str	r3, [r4, #32]                                 <== NOT EXECUTED
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
a0008198:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
a000819c:	e7d05003 	ldrb	r5, [r0, r3]                                 <== NOT EXECUTED
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
a00081a0:	0afffff2 	beq	a0008170 <erase+0x6c>                         <== NOT EXECUTED
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
a00081a4:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a00081a8:	1a000001 	bne	a00081b4 <erase+0xb0>                         <== NOT EXECUTED
a00081ac:	e3110010 	tst	r1, #16                                       <== NOT EXECUTED
a00081b0:	0a000033 	beq	a0008284 <erase+0x180>                        <== NOT EXECUTED
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
a00081b4:	e3550009 	cmp	r5, #9                                        <== NOT EXECUTED
a00081b8:	0a00000d 	beq	a00081f4 <erase+0xf0>                         <== NOT EXECUTED
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
a00081bc:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
a00081c0:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
a00081c4:	e7d33005 	ldrb	r3, [r3, r5]                                 <== NOT EXECUTED
a00081c8:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a00081cc:	1affffe5 	bne	a0008168 <erase+0x64>                         <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
          rtems_termios_puts ("\b \b", 3, tty);                       
a00081d0:	e59f0134 	ldr	r0, [pc, #308]	; a000830c <erase+0x208>       <== NOT EXECUTED
a00081d4:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a00081d8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a00081dc:	ebffff01 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
          if (tty->column)                                            
a00081e0:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a00081e4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            tty->column--;                                            
a00081e8:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
a00081ec:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
a00081f0:	eaffffde 	b	a0008170 <erase+0x6c>                           <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
a00081f4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
        int col = tty->read_start_column;                             
a00081f8:	e594502c 	ldr	r5, [r4, #44]	; 0x2c                          <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
a00081fc:	0a000011 	beq	a0008248 <erase+0x144>                        <== NOT EXECUTED
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
a0008200:	e5978000 	ldr	r8, [r7]                                      <== NOT EXECUTED
    if (tty->termios.c_lflag & ECHO) {                                
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
        int col = tty->read_start_column;                             
        int i = 0;                                                    
a0008204:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
            if (tty->termios.c_lflag & ECHOCTL)                       
a0008208:	e201ac02 	and	sl, r1, #512	; 0x200                          <== NOT EXECUTED
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
a000820c:	e7d01002 	ldrb	r1, [r0, r2]                                 <== NOT EXECUTED
a0008210:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
          if (c == '\t') {                                            
a0008214:	e3510009 	cmp	r1, #9                                        <== NOT EXECUTED
            col = (col | 7) + 1;                                      
a0008218:	03855007 	orreq	r5, r5, #7                                  <== NOT EXECUTED
          } else if (iscntrl (c)) {                                   
a000821c:	e088c001 	add	ip, r8, r1                                    <== NOT EXECUTED
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
a0008220:	02855001 	addeq	r5, r5, #1                                  <== NOT EXECUTED
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
a0008224:	0a000005 	beq	a0008240 <erase+0x13c>                        <== NOT EXECUTED
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
a0008228:	e5dcc001 	ldrb	ip, [ip, #1]                                 <== NOT EXECUTED
a000822c:	e31c0020 	tst	ip, #32                                       <== NOT EXECUTED
            if (tty->termios.c_lflag & ECHOCTL)                       
              col += 2;                                               
          } else {                                                    
            col++;                                                    
a0008230:	02855001 	addeq	r5, r5, #1                                  <== NOT EXECUTED
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
a0008234:	0a000001 	beq	a0008240 <erase+0x13c>                        <== NOT EXECUTED
            if (tty->termios.c_lflag & ECHOCTL)                       
a0008238:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
              col += 2;                                               
a000823c:	12855002 	addne	r5, r5, #2                                  <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
a0008240:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0008244:	1afffff0 	bne	a000820c <erase+0x108>                        <== NOT EXECUTED
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
a0008248:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a000824c:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
a0008250:	aaffffc6 	bge	a0008170 <erase+0x6c>                         <== NOT EXECUTED
          rtems_termios_puts ("\b", 1, tty);                          
a0008254:	e59f00b4 	ldr	r0, [pc, #180]	; a0008310 <erase+0x20c>       <== NOT EXECUTED
a0008258:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000825c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0008260:	ebfffee0 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
          tty->column--;                                              
a0008264:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0008268:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
a000826c:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
a0008270:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
a0008274:	cafffff6 	bgt	a0008254 <erase+0x150>                        <== NOT EXECUTED
a0008278:	eaffffbc 	b	a0008170 <erase+0x6c>                           <== NOT EXECUTED
{                                                                     
  if (tty->ccount == 0)                                               
    return;                                                           
  if (lineFlag) {                                                     
    if (!(tty->termios.c_lflag & ECHO)) {                             
      tty->ccount = 0;                                                
a000827c:	e5802020 	str	r2, [r0, #32]                                 <== NOT EXECUTED
      return;                                                         
a0008280:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
        echo (tty->termios.c_cc[VERASE], tty);                        
a0008284:	e5d40043 	ldrb	r0, [r4, #67]	; 0x43                         <== NOT EXECUTED
a0008288:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
      break;                                                          
  }                                                                   
}                                                                     
a000828c:	e8bd45f0 	pop	{r4, r5, r6, r7, r8, sl, lr}                  <== NOT EXECUTED
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
        echo (tty->termios.c_cc[VERASE], tty);                        
a0008290:	eaffff76 	b	a0008070 <echo>                                 <== NOT EXECUTED
a0008294:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
          rtems_termios_puts ("\b \b", 3, tty);                       
a0008298:	e59f006c 	ldr	r0, [pc, #108]	; a000830c <erase+0x208>       <== NOT EXECUTED
a000829c:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a00082a0:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a00082a4:	ebfffecf 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
          if (tty->column)                                            
a00082a8:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a00082ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            tty->column--;                                            
a00082b0:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
a00082b4:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
a00082b8:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
a00082bc:	e7d33005 	ldrb	r3, [r3, r5]                                 <== NOT EXECUTED
a00082c0:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a00082c4:	0affffc1 	beq	a00081d0 <erase+0xcc>                         <== NOT EXECUTED
a00082c8:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
a00082cc:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
a00082d0:	0affffa6 	beq	a0008170 <erase+0x6c>                         <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
a00082d4:	e59f0030 	ldr	r0, [pc, #48]	; a000830c <erase+0x208>        <== NOT EXECUTED
a00082d8:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a00082dc:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a00082e0:	ebfffec0 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
          if (tty->column)                                            
a00082e4:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a00082e8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            tty->column--;                                            
a00082ec:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
a00082f0:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
a00082f4:	eaffff9d 	b	a0008170 <erase+0x6c>                           <== NOT EXECUTED
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
      tty->ccount = 0;                                                
      echo (tty->termios.c_cc[VKILL], tty);                           
      if (tty->termios.c_lflag & ECHOK)                               
        echo ('\n', tty);                                             
a00082f8:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a00082fc:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
      break;                                                          
  }                                                                   
}                                                                     
a0008300:	e8bd45f0 	pop	{r4, r5, r6, r7, r8, sl, lr}                  <== NOT EXECUTED
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
      tty->ccount = 0;                                                
      echo (tty->termios.c_cc[VKILL], tty);                           
      if (tty->termios.c_lflag & ECHOK)                               
        echo ('\n', tty);                                             
a0008304:	eaffff59 	b	a0008070 <echo>                                 <== NOT EXECUTED
                                                                      

a0007214 <fchdir>: ) { rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd );
a0007214:	e59f313c 	ldr	r3, [pc, #316]	; a0007358 <fchdir+0x144>      <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int fchdir(                                                           
  int       fd                                                        
)                                                                     
{                                                                     
a0007218:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_filesystem_location_info_t loc, saved;                        
                                                                      
  rtems_libio_check_fd( fd );                                         
a000721c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int fchdir(                                                           
  int       fd                                                        
)                                                                     
{                                                                     
a0007220:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_filesystem_location_info_t loc, saved;                        
                                                                      
  rtems_libio_check_fd( fd );                                         
a0007224:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0007228:	2a000040 	bcs	a0007330 <fchdir+0x11c>                       <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a000722c:	e59f3128 	ldr	r3, [pc, #296]	; a000735c <fchdir+0x148>      <== NOT EXECUTED
a0007230:	e3a05038 	mov	r5, #56	; 0x38                                <== NOT EXECUTED
a0007234:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007238:	e0253590 	mla	r5, r0, r5, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a000723c:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a0007240:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0007244:	0a000039 	beq	a0007330 <fchdir+0x11c>                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fchmod().                                       
   */                                                                 
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );             
a0007248:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a000724c:	0a00003c 	beq	a0007344 <fchdir+0x130>                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can change directory into this node.                  
   */                                                                 
                                                                      
  if (  (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=        
a0007250:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
a0007254:	e2855018 	add	r5, r5, #24                                   <== NOT EXECUTED
a0007258:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000725c:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a0007260:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007264:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0007268:	e1a0e000 	mov	lr, r0                                        <== NOT EXECUTED
a000726c:	1a000022 	bne	a00072fc <fchdir+0xe8>                        <== NOT EXECUTED
   *         but note the race condition. Threads who                 
   *         share their rtems_filesystem_current better              
   *         be synchronized!                                         
   */                                                                 
                                                                      
  saved                    = rtems_filesystem_current;                
a0007270:	e59f60e8 	ldr	r6, [pc, #232]	; a0007360 <fchdir+0x14c>      <== NOT EXECUTED
a0007274:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0007278:	e1a0b004 	mov	fp, r4                                        <== NOT EXECUTED
a000727c:	e5969000 	ldr	r9, [r6]                                      <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
a0007280:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
a0007284:	e28d8018 	add	r8, sp, #24                                   <== NOT EXECUTED
   *         but note the race condition. Threads who                 
   *         share their rtems_filesystem_current better              
   *         be synchronized!                                         
   */                                                                 
                                                                      
  saved                    = rtems_filesystem_current;                
a0007288:	e289c004 	add	ip, r9, #4                                    <== NOT EXECUTED
a000728c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007290:	e8ab000f 	stmia	fp!, {r0, r1, r2, r3}                       <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
a0007294:	e8b5000f 	ldm	r5!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007298:	e595a000 	ldr	sl, [r5]                                      <== NOT EXECUTED
a000729c:	e2895004 	add	r5, r9, #4                                    <== NOT EXECUTED
   *         but note the race condition. Threads who                 
   *         share their rtems_filesystem_current better              
   *         be synchronized!                                         
   */                                                                 
                                                                      
  saved                    = rtems_filesystem_current;                
a00072a0:	e59c9000 	ldr	r9, [ip]                                      <== NOT EXECUTED
a00072a4:	e58b9000 	str	r9, [fp]                                      <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
a00072a8:	e8a5000f 	stmia	r5!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a00072ac:	e58ca000 	str	sl, [ip]                                      <== NOT EXECUTED
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
a00072b0:	e59f00ac 	ldr	r0, [pc, #172]	; a0007364 <fchdir+0x150>      <== NOT EXECUTED
a00072b4:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
a00072b8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a00072bc:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a00072c0:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a00072c4:	ebffff98 	bl	a000712c <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a00072c8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a00072cc:	1a00000f 	bne	a0007310 <fchdir+0xfc>                        <== NOT EXECUTED
    /* cloning failed; restore original and bail out */               
    rtems_filesystem_current = saved;                                 
    return -1;                                                        
  }                                                                   
  /* release the old one */                                           
  rtems_filesystem_freenode( &saved );                                
a00072d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00072d4:	eb000065 	bl	a0007470 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  rtems_filesystem_current = loc;                                     
a00072d8:	e8b8000f 	ldm	r8!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a00072dc:	e596c000 	ldr	ip, [r6]                                      <== NOT EXECUTED
a00072e0:	e5984000 	ldr	r4, [r8]                                      <== NOT EXECUTED
a00072e4:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
a00072e8:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a00072ec:	e58c4000 	str	r4, [ip]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a00072f0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00072f4:	e28dd02c 	add	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
a00072f8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
   * Verify you can change directory into this node.                  
   */                                                                 
                                                                      
  if (  (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=        
                                          RTEMS_FILESYSTEM_DIRECTORY ) {
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a00072fc:	eb002c15 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a0007300:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a0007304:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007308:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a000730c:	eafffff7 	b	a00072f0 <fchdir+0xdc>                          <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
    /* cloning failed; restore original and bail out */               
    rtems_filesystem_current = saved;                                 
a0007310:	e596c000 	ldr	ip, [r6]                                      <== NOT EXECUTED
a0007314:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007318:	e59b4000 	ldr	r4, [fp]                                      <== NOT EXECUTED
a000731c:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
a0007320:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
    return -1;                                                        
a0007324:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
  rtems_filesystem_current = iop->pathinfo;                           
                                                                      
  /* clone the current node */                                        
  if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {           
    /* cloning failed; restore original and bail out */               
    rtems_filesystem_current = saved;                                 
a0007328:	e58c4000 	str	r4, [ip]                                      <== NOT EXECUTED
    return -1;                                                        
a000732c:	eaffffef 	b	a00072f0 <fchdir+0xdc>                          <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_filesystem_location_info_t loc, saved;                        
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0007330:	eb002c08 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a0007334:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0007338:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000733c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0007340:	eaffffea 	b	a00072f0 <fchdir+0xdc>                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fchmod().                                       
   */                                                                 
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );             
a0007344:	eb002c03 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a0007348:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000734c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007350:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0007354:	eaffffe5 	b	a00072f0 <fchdir+0xdc>                          <== NOT EXECUTED
                                                                      

a0007368 <fchmod>: mode_t mode ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
a0007368:	e59f306c 	ldr	r3, [pc, #108]	; a00073dc <fchmod+0x74>       <== NOT EXECUTED
                                                                      
int fchmod(                                                           
  int       fd,                                                       
  mode_t    mode                                                      
)                                                                     
{                                                                     
a000736c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a0007370:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007374:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0007378:	2a00000d 	bcs	a00073b4 <fchmod+0x4c>                        <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a000737c:	e59f305c 	ldr	r3, [pc, #92]	; a00073e0 <fchmod+0x78>        <== NOT EXECUTED
a0007380:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
a0007384:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007388:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a000738c:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a0007390:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0007394:	0a000006 	beq	a00073b4 <fchmod+0x4c>                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fchmod().                                       
   */                                                                 
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0007398:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a000739c:	0a000009 	beq	a00073c8 <fchmod+0x60>                        <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 
a00073a0:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
a00073a4:	e2800018 	add	r0, r0, #24                                   <== NOT EXECUTED
a00073a8:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
a00073ac:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a00073b0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
{                                                                     
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a00073b4:	eb002be7 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a00073b8:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a00073bc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00073c0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00073c4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fchmod().                                       
   */                                                                 
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a00073c8:	eb002be2 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a00073cc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00073d0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00073d4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00073d8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00073e4 <fchown>: gid_t group ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
a00073e4:	e59f307c 	ldr	r3, [pc, #124]	; a0007468 <fchown+0x84>       <== NOT EXECUTED
int fchown(                                                           
  int   fd,                                                           
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
a00073e8:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a00073ec:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a00073f0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int fchown(                                                           
  int   fd,                                                           
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
a00073f4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a00073f8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
int fchown(                                                           
  int   fd,                                                           
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
a00073fc:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
a0007400:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a0007404:	2a00000d 	bcs	a0007440 <fchown+0x5c>                        <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0007408:	e59f305c 	ldr	r3, [pc, #92]	; a000746c <fchown+0x88>        <== NOT EXECUTED
a000740c:	e3a0c038 	mov	ip, #56	; 0x38                                <== NOT EXECUTED
a0007410:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007414:	e020309c 	mla	r0, ip, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0007418:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a000741c:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0007420:	0a000006 	beq	a0007440 <fchown+0x5c>                        <== NOT EXECUTED
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0007424:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a0007428:	0a000009 	beq	a0007454 <fchown+0x70>                        <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
a000742c:	e5903024 	ldr	r3, [r0, #36]	; 0x24                          <== NOT EXECUTED
a0007430:	e2800018 	add	r0, r0, #24                                   <== NOT EXECUTED
a0007434:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0007438:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a000743c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
{                                                                     
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0007440:	eb002bc4 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a0007444:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0007448:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000744c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007450:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0007454:	eb002bbf 	bl	a0012358 <__errno>                             <== NOT EXECUTED
a0007458:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000745c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007460:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007464:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0006d08 <fcntl>: int fcntl( int fd, int cmd, ... ) {
a0006d08:	e92d000e 	push	{r1, r2, r3}                                 <== NOT EXECUTED
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0006d0c:	e59f21d8 	ldr	r2, [pc, #472]	; a0006eec <fcntl+0x1e4>       <== NOT EXECUTED
int fcntl(                                                            
  int fd,                                                             
  int cmd,                                                            
  ...                                                                 
)                                                                     
{                                                                     
a0006d10:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0006d14:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
int fcntl(                                                            
  int fd,                                                             
  int cmd,                                                            
  ...                                                                 
)                                                                     
{                                                                     
a0006d18:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
a0006d1c:	e28d3028 	add	r3, sp, #40	; 0x28                            <== NOT EXECUTED
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0006d20:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
int fcntl(                                                            
  int fd,                                                             
  int cmd,                                                            
  ...                                                                 
)                                                                     
{                                                                     
a0006d24:	e59d4024 	ldr	r4, [sp, #36]	; 0x24                          <== NOT EXECUTED
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
a0006d28:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0006d2c:	2a000062 	bcs	a0006ebc <fcntl+0x1b4>                        <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0006d30:	e59f61b8 	ldr	r6, [pc, #440]	; a0006ef0 <fcntl+0x1e8>       <== NOT EXECUTED
a0006d34:	e3a05038 	mov	r5, #56	; 0x38                                <== NOT EXECUTED
a0006d38:	e5961000 	ldr	r1, [r6]                                      <== NOT EXECUTED
a0006d3c:	e0251590 	mla	r5, r0, r5, r1                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0006d40:	e595c014 	ldr	ip, [r5, #20]                                 <== NOT EXECUTED
a0006d44:	e31c0c01 	tst	ip, #256	; 0x100                              <== NOT EXECUTED
a0006d48:	0a00005b 	beq	a0006ebc <fcntl+0x1b4>                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
a0006d4c:	e3540009 	cmp	r4, #9                                        <== NOT EXECUTED
a0006d50:	979ff104 	ldrls	pc, [pc, r4, lsl #2]                        <== NOT EXECUTED
a0006d54:	ea000028 	b	a0006dfc <fcntl+0xf4>                           <== NOT EXECUTED
a0006d58:	a0006e0c 	.word	0xa0006e0c                                  <== NOT EXECUTED
a0006d5c:	a0006e74 	.word	0xa0006e74                                  <== NOT EXECUTED
a0006d60:	a0006e84 	.word	0xa0006e84                                  <== NOT EXECUTED
a0006d64:	a0006ea4 	.word	0xa0006ea4                                  <== NOT EXECUTED
a0006d68:	a0006da4 	.word	0xa0006da4                                  <== NOT EXECUTED
a0006d6c:	a0006d80 	.word	0xa0006d80                                  <== NOT EXECUTED
a0006d70:	a0006d80 	.word	0xa0006d80                                  <== NOT EXECUTED
a0006d74:	a0006d80 	.word	0xa0006d80                                  <== NOT EXECUTED
a0006d78:	a0006d80 	.word	0xa0006d80                                  <== NOT EXECUTED
a0006d7c:	a0006d80 	.word	0xa0006d80                                  <== NOT EXECUTED
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
a0006d80:	eb002d06 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0006d84:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
a0006d88:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0006d8c:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
a0006d90:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0006d94:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0006d98:	e8bd47f0 	pop	{r4, r5, r6, r7, r8, r9, sl, lr}              <== NOT EXECUTED
a0006d9c:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a0006da0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
      break;                                                          
                                                                      
    case F_SETFL:                                                     
      flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );           
a0006da4:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a0006da8:	eb00018e 	bl	a00073e8 <rtems_libio_fcntl_flags>             <== NOT EXECUTED
                                                                      
      /*                                                              
       *  XXX If we are turning on append, should we seek to the end? 
       */                                                             
                                                                      
      iop->flags = (iop->flags & ~mask) | (flags & mask);             
a0006dac:	e5952014 	ldr	r2, [r5, #20]                                 <== NOT EXECUTED
a0006db0:	e3a03c02 	mov	r3, #512	; 0x200                              <== NOT EXECUTED
a0006db4:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0006db8:	e3c22c02 	bic	r2, r2, #512	; 0x200                          <== NOT EXECUTED
a0006dbc:	e0003003 	and	r3, r0, r3                                    <== NOT EXECUTED
a0006dc0:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
a0006dc4:	e1833002 	orr	r3, r3, r2                                    <== NOT EXECUTED
a0006dc8:	e5853014 	str	r3, [r5, #20]                                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_libio_t *diop;                                                
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
a0006dcc:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
    int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );         
a0006dd0:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0006dd4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006dd8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0006ddc:	e5933030 	ldr	r3, [r3, #48]	; 0x30                          <== NOT EXECUTED
a0006de0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    if (err) {                                                        
a0006de4:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0006de8:	0affffe8 	beq	a0006d90 <fcntl+0x88>                         <== NOT EXECUTED
      errno = err;                                                    
a0006dec:	eb002ceb 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
      ret = -1;                                                       
a0006df0:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
    int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );         
    if (err) {                                                        
      errno = err;                                                    
a0006df4:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
a0006df8:	eaffffe4 	b	a0006d90 <fcntl+0x88>                           <== NOT EXECUTED
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
a0006dfc:	eb002ce7 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0006e00:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006e04:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006e08:	eaffffdf 	b	a0006d8c <fcntl+0x84>                           <== NOT EXECUTED
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
    case F_DUPFD:        /* dup */                                    
      fd2 = va_arg( ap, int );                                        
a0006e0c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
      if ( fd2 )                                                      
a0006e10:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006e14:	0a00002d 	beq	a0006ed0 <fcntl+0x1c8>                        <== NOT EXECUTED
        diop = rtems_libio_iop( fd2 );                                
a0006e18:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0006e1c:	93a08000 	movls	r8, #0                                      <== NOT EXECUTED
a0006e20:	91a09008 	movls	r9, r8                                      <== NOT EXECUTED
a0006e24:	9a000002 	bls	a0006e34 <fcntl+0x12c>                        <== NOT EXECUTED
a0006e28:	e3a09038 	mov	r9, #56	; 0x38                                <== NOT EXECUTED
a0006e2c:	e0291993 	mla	r9, r3, r9, r1                                <== NOT EXECUTED
a0006e30:	e1a08009 	mov	r8, r9                                        <== NOT EXECUTED
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
      ret = (int) (diop - rtems_libio_iops);                          
a0006e34:	e0618008 	rsb	r8, r1, r8                                    <== NOT EXECUTED
a0006e38:	e1a081c8 	asr	r8, r8, #3                                    <== NOT EXECUTED
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
a0006e3c:	e289a018 	add	sl, r9, #24                                   <== NOT EXECUTED
      ret = (int) (diop - rtems_libio_iops);                          
a0006e40:	e0886188 	add	r6, r8, r8, lsl #3                            <== NOT EXECUTED
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
a0006e44:	e2857018 	add	r7, r5, #24                                   <== NOT EXECUTED
a0006e48:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0006e4c:	e8aa000f 	stmia	sl!, {r0, r1, r2, r3}                       <== NOT EXECUTED
      ret = (int) (diop - rtems_libio_iops);                          
a0006e50:	e0866306 	add	r6, r6, r6, lsl #6                            <== NOT EXECUTED
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
a0006e54:	e5973000 	ldr	r3, [r7]                                      <== NOT EXECUTED
      ret = (int) (diop - rtems_libio_iops);                          
a0006e58:	e0886186 	add	r6, r8, r6, lsl #3                            <== NOT EXECUTED
          ret = -1;                                                   
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
a0006e5c:	e589c014 	str	ip, [r9, #20]                                 <== NOT EXECUTED
      diop->pathinfo   = iop->pathinfo;                               
      ret = (int) (diop - rtems_libio_iops);                          
a0006e60:	e0866786 	add	r6, r6, r6, lsl #15                           <== NOT EXECUTED
          break;                                                      
        }                                                             
      }                                                               
                                                                      
      diop->flags      = iop->flags;                                  
      diop->pathinfo   = iop->pathinfo;                               
a0006e64:	e58a3000 	str	r3, [sl]                                      <== NOT EXECUTED
      ret = (int) (diop - rtems_libio_iops);                          
a0006e68:	e0888186 	add	r8, r8, r6, lsl #3                            <== NOT EXECUTED
a0006e6c:	e2688000 	rsb	r8, r8, #0                                    <== NOT EXECUTED
a0006e70:	ea00000e 	b	a0006eb0 <fcntl+0x1a8>                          <== NOT EXECUTED
      break;                                                          
                                                                      
    case F_GETFD:        /* get f_flags */                            
      ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);          
a0006e74:	e31c0b02 	tst	ip, #2048	; 0x800                             <== NOT EXECUTED
a0006e78:	03a08000 	moveq	r8, #0                                      <== NOT EXECUTED
a0006e7c:	13a08001 	movne	r8, #1                                      <== NOT EXECUTED
a0006e80:	eaffffd2 	b	a0006dd0 <fcntl+0xc8>                           <== NOT EXECUTED
       *  if a new process is exec()'ed.  Since RTEMS does not support
       *  processes, then we can ignore this one except to make       
       *  F_GETFD work.                                               
       */                                                             
                                                                      
      if ( va_arg( ap, int ) )                                        
a0006e84:	e5938000 	ldr	r8, [r3]                                      <== NOT EXECUTED
a0006e88:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
a0006e8c:	138ccb02 	orrne	ip, ip, #2048	; 0x800                       <== NOT EXECUTED
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
a0006e90:	03cccb02 	biceq	ip, ip, #2048	; 0x800                       <== NOT EXECUTED
       *  processes, then we can ignore this one except to make       
       *  F_GETFD work.                                               
       */                                                             
                                                                      
      if ( va_arg( ap, int ) )                                        
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
a0006e94:	1585c014 	strne	ip, [r5, #20]                               <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  rtems_libio_t *diop;                                                
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
a0006e98:	13a08000 	movne	r8, #0                                      <== NOT EXECUTED
       */                                                             
                                                                      
      if ( va_arg( ap, int ) )                                        
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
a0006e9c:	0585c014 	streq	ip, [r5, #20]                               <== NOT EXECUTED
a0006ea0:	eaffffca 	b	a0006dd0 <fcntl+0xc8>                           <== NOT EXECUTED
      break;                                                          
                                                                      
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
a0006ea4:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
a0006ea8:	eb00015b 	bl	a000741c <rtems_libio_to_fcntl_flags>          <== NOT EXECUTED
a0006eac:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
a0006eb0:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a0006eb4:	aaffffc5 	bge	a0006dd0 <fcntl+0xc8>                         <== NOT EXECUTED
a0006eb8:	eaffffb4 	b	a0006d90 <fcntl+0x88>                           <== NOT EXECUTED
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0006ebc:	eb002cb7 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0006ec0:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0006ec4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006ec8:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
a0006ecc:	eaffffaf 	b	a0006d90 <fcntl+0x88>                           <== NOT EXECUTED
      fd2 = va_arg( ap, int );                                        
      if ( fd2 )                                                      
        diop = rtems_libio_iop( fd2 );                                
      else {                                                          
        /* allocate a file control block */                           
        diop = rtems_libio_allocate();                                
a0006ed0:	eb000164 	bl	a0007468 <rtems_libio_allocate>                <== NOT EXECUTED
        if ( diop == 0 ) {                                            
a0006ed4:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
a0006ed8:	0affffab 	beq	a0006d8c <fcntl+0x84>                         <== NOT EXECUTED
a0006edc:	e595c014 	ldr	ip, [r5, #20]                                 <== NOT EXECUTED
a0006ee0:	e1a08009 	mov	r8, r9                                        <== NOT EXECUTED
a0006ee4:	e5961000 	ldr	r1, [r6]                                      <== NOT EXECUTED
a0006ee8:	eaffffd1 	b	a0006e34 <fcntl+0x12c>                          <== NOT EXECUTED
                                                                      

a0006f04 <fdatasync>: int fd ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
a0006f04:	e59f3068 	ldr	r3, [pc, #104]	; a0006f74 <fdatasync+0x70>    <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int fdatasync(                                                        
  int     fd                                                          
)                                                                     
{                                                                     
a0006f08:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a0006f0c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006f10:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0006f14:	2a00000c 	bcs	a0006f4c <fdatasync+0x48>                     <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0006f18:	e59f3058 	ldr	r3, [pc, #88]	; a0006f78 <fdatasync+0x74>     <== NOT EXECUTED
a0006f1c:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
a0006f20:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006f24:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0006f28:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a0006f2c:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0006f30:	0a000005 	beq	a0006f4c <fdatasync+0x48>                     <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0006f34:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a0006f38:	0a000008 	beq	a0006f60 <fdatasync+0x5c>                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fdatasync().                                    
   */                                                                 
                                                                      
  return (*iop->pathinfo.handlers->fdatasync_h)( iop );               
a0006f3c:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
a0006f40:	e593302c 	ldr	r3, [r3, #44]	; 0x2c                          <== NOT EXECUTED
a0006f44:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a0006f48:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
{                                                                     
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0006f4c:	eb002c93 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0006f50:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0006f54:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006f58:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006f5c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0006f60:	eb002c8e 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0006f64:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006f68:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006f6c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006f70:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00105d8 <fifo_open>: */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) {
a00105d8:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
                                                                      
static rtems_status_code pipe_lock(void)                              
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
a00105dc:	e59f5428 	ldr	r5, [pc, #1064]	; a0010a0c <fifo_open+0x434>  <== NOT EXECUTED
 */                                                                   
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a00105e0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a00105e4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
static rtems_status_code pipe_lock(void)                              
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
a00105e8:	e5958000 	ldr	r8, [r5]                                      <== NOT EXECUTED
 */                                                                   
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a00105ec:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
                                                                      
static rtems_status_code pipe_lock(void)                              
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
a00105f0:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a00105f4:	0a000024 	beq	a001068c <fifo_open+0xb4>                     <== NOT EXECUTED
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
    sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a00105f8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00105fc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0010600:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0010604:	ebffed88 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
a0010608:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
a001060c:	1a0000d3 	bne	a0010960 <fifo_open+0x388>                    <== NOT EXECUTED
                                                                      
  err = pipe_lock();                                                  
  if (err)                                                            
    return err;                                                       
                                                                      
  pipe = *pipep;                                                      
a0010610:	e5945000 	ldr	r5, [r4]                                      <== NOT EXECUTED
  if (pipe == NULL) {                                                 
a0010614:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0010618:	0a00007f 	beq	a001081c <fifo_open+0x244>                    <== NOT EXECUTED
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a001061c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010620:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010624:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0010628:	ebffed7f 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
a001062c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010630:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010634:	01a07000 	moveq	r7, r0                                      <== NOT EXECUTED
a0010638:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
a001063c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010640:	0a0000b6 	beq	a0010920 <fifo_open+0x348>                    <== NOT EXECUTED
    else                                                              
      *pipep = pipe;                                                  
  }                                                                   
                                                                      
out:                                                                  
  pipe_unlock();                                                      
a0010644:	ebffffa9 	bl	a00104f0 <pipe_unlock>                         <== NOT EXECUTED
  pipe_control_t *pipe;                                               
  unsigned int prevCounter;                                           
  int err;                                                            
                                                                      
  err = pipe_new(pipep);                                              
  if (err)                                                            
a0010648:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a001064c:	1a00000b 	bne	a0010680 <fifo_open+0xa8>                     <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
a0010650:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
  int err;                                                            
                                                                      
  err = pipe_new(pipep);                                              
  if (err)                                                            
    return err;                                                       
  pipe = *pipep;                                                      
a0010654:	e5945000 	ldr	r5, [r4]                                      <== NOT EXECUTED
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
a0010658:	e2033006 	and	r3, r3, #6                                    <== NOT EXECUTED
a001065c:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a0010660:	0a000015 	beq	a00106bc <fifo_open+0xe4>                     <== NOT EXECUTED
a0010664:	e3530006 	cmp	r3, #6                                        <== NOT EXECUTED
a0010668:	0a000057 	beq	a00107cc <fifo_open+0x1f4>                    <== NOT EXECUTED
a001066c:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0010670:	0a000035 	beq	a001074c <fifo_open+0x174>                    <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
a0010674:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010678:	ebffedb4 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
  return 0;                                                           
a001067c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
  return err;                                                         
}                                                                     
a0010680:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010684:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0010688:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a001068c:	e59f737c 	ldr	r7, [pc, #892]	; a0010a10 <fifo_open+0x438>   <== NOT EXECUTED
a0010690:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0010694:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a0010698:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a001069c:	ebffed62 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
    rtems_libio_lock();                                               
                                                                      
    if (pipe_semaphore == RTEMS_ID_NONE) {                            
a00106a0:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00106a4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00106a8:	0a0000a1 	beq	a0010934 <fifo_open+0x35c>                    <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a00106ac:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a00106b0:	ebffeda6 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
a00106b4:	e5958000 	ldr	r8, [r5]                                      <== NOT EXECUTED
a00106b8:	eaffffce 	b	a00105f8 <fifo_open+0x20>                       <== NOT EXECUTED
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
a00106bc:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
a00106c0:	e5951024 	ldr	r1, [r5, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
a00106c4:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
a00106c8:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
a00106cc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
a00106d0:	e5851024 	str	r1, [r5, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
a00106d4:	e5852014 	str	r2, [r5, #20]                                 <== NOT EXECUTED
a00106d8:	0a0000a2 	beq	a0010968 <fifo_open+0x390>                    <== NOT EXECUTED
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
a00106dc:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
a00106e0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00106e4:	1affffe2 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
a00106e8:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
a00106ec:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
        err = -ENXIO;                                                 
        goto out_error;                                               
      }                                                               
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
a00106f0:	05957020 	ldreq	r7, [r5, #32]                               <== NOT EXECUTED
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
a00106f4:	0a000007 	beq	a0010718 <fifo_open+0x140>                    <== NOT EXECUTED
a00106f8:	ea0000b2 	b	a00109c8 <fifo_open+0x3f0>                      <== NOT EXECUTED
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_WRITEWAIT(pipe))                                 
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
a00106fc:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010700:	ebffed49 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010704:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010708:	1a00000a 	bne	a0010738 <fifo_open+0x160>                    <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->readerCounter);                 
a001070c:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0010710:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
a0010714:	1affffd6 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
a0010718:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a001071c:	ebffed8b 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
          if (! PIPE_WRITEWAIT(pipe))                                 
a0010720:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010724:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a0010728:	eb0004cb 	bl	a0011a5c <rtems_barrier_wait>                  <== NOT EXECUTED
a001072c:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
a0010730:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_WRITEWAIT(pipe))                                 
a0010734:	0afffff0 	beq	a00106fc <fifo_open+0x124>                    <== NOT EXECUTED
        goto out_error;                                               
      }                                                               
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
a0010738:	e3e07003 	mvn	r7, #3                                        <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
a001073c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010740:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010744:	ebffff6d 	bl	a0010500 <pipe_release>                        <== NOT EXECUTED
  return err;                                                         
a0010748:	eaffffcc 	b	a0010680 <fifo_open+0xa8>                       <== NOT EXECUTED
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
a001074c:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
a0010750:	e5951020 	ldr	r1, [r5, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a0010754:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
a0010758:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a001075c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
a0010760:	e5851020 	str	r1, [r5, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a0010764:	e5852010 	str	r2, [r5, #16]                                 <== NOT EXECUTED
a0010768:	0a000086 	beq	a0010988 <fifo_open+0x3b0>                    <== NOT EXECUTED
        PIPE_WAKEUPWRITERS(pipe);                                     
                                                                      
      if (pipe->Writers == 0) {                                       
a001076c:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a0010770:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010774:	1affffbe 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
a0010778:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
a001077c:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a0010780:	1affffbb 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
a0010784:	e5957024 	ldr	r7, [r5, #36]	; 0x24                          <== NOT EXECUTED
a0010788:	ea000006 	b	a00107a8 <fifo_open+0x1d0>                      <== NOT EXECUTED
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_READWAIT(pipe))                                  
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
a001078c:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010790:	ebffed25 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010794:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010798:	1affffe6 	bne	a0010738 <fifo_open+0x160>                    <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->writerCounter);                 
a001079c:	e5953024 	ldr	r3, [r5, #36]	; 0x24                          <== NOT EXECUTED
a00107a0:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
a00107a4:	1affffb2 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
a00107a8:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a00107ac:	ebffed67 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
          if (! PIPE_READWAIT(pipe))                                  
a00107b0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00107b4:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a00107b8:	eb0004a7 	bl	a0011a5c <rtems_barrier_wait>                  <== NOT EXECUTED
a00107bc:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
a00107c0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
          if (! PIPE_READWAIT(pipe))                                  
a00107c4:	0afffff0 	beq	a001078c <fifo_open+0x1b4>                    <== NOT EXECUTED
a00107c8:	eaffffda 	b	a0010738 <fifo_open+0x160>                      <== NOT EXECUTED
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
a00107cc:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
a00107d0:	e5951020 	ldr	r1, [r5, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a00107d4:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
a00107d8:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a00107dc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
a00107e0:	e5851020 	str	r1, [r5, #32]                                 <== NOT EXECUTED
      if (pipe->Readers ++ == 0)                                      
a00107e4:	e5852010 	str	r2, [r5, #16]                                 <== NOT EXECUTED
a00107e8:	0a000062 	beq	a0010978 <fifo_open+0x3a0>                    <== NOT EXECUTED
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
a00107ec:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
a00107f0:	e5951024 	ldr	r1, [r5, #36]	; 0x24                          <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
a00107f4:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
a00107f8:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
a00107fc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
a0010800:	e5851024 	str	r1, [r5, #36]	; 0x24                          <== NOT EXECUTED
      if (pipe->Writers ++ == 0)                                      
a0010804:	e5852014 	str	r2, [r5, #20]                                 <== NOT EXECUTED
a0010808:	1affff99 	bne	a0010674 <fifo_open+0x9c>                     <== NOT EXECUTED
        PIPE_WAKEUPREADERS(pipe);                                     
a001080c:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a0010810:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a0010814:	eb000478 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010818:	eaffff95 	b	a0010674 <fifo_open+0x9c>                       <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
a001081c:	e3a00034 	mov	r0, #52	; 0x34                                <== NOT EXECUTED
a0010820:	ebffdfed 	bl	a00087dc <malloc>                              <== NOT EXECUTED
  if (pipe == NULL)                                                   
a0010824:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
a0010828:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a001082c:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  if (pipe == NULL)                                                   
a0010830:	0a000070 	beq	a00109f8 <fifo_open+0x420>                    <== NOT EXECUTED
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
a0010834:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0010838:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a001083c:	e2822004 	add	r2, r2, #4                                    <== NOT EXECUTED
a0010840:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010844:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010848:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a001084c:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010850:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010854:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010858:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a001085c:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010860:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
a0010864:	e482a004 	str	sl, [r2], #4                                  <== NOT EXECUTED
                                                                      
  pipe->Size = PIPE_BUF;                                              
a0010868:	e3a03c02 	mov	r3, #512	; 0x200                              <== NOT EXECUTED
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
  if (pipe == NULL)                                                   
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
a001086c:	e582a000 	str	sl, [r2]                                      <== NOT EXECUTED
                                                                      
  pipe->Size = PIPE_BUF;                                              
  pipe->Buffer = malloc(pipe->Size);                                  
a0010870:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
  pipe = malloc(sizeof(pipe_control_t));                              
  if (pipe == NULL)                                                   
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
                                                                      
  pipe->Size = PIPE_BUF;                                              
a0010874:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
  pipe->Buffer = malloc(pipe->Size);                                  
a0010878:	ebffdfd7 	bl	a00087dc <malloc>                              <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
a001087c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  if (pipe == NULL)                                                   
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
                                                                      
  pipe->Size = PIPE_BUF;                                              
  pipe->Buffer = malloc(pipe->Size);                                  
a0010880:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
a0010884:	0a000059 	beq	a00109f0 <fifo_open+0x418>                    <== NOT EXECUTED
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'r', c),                          
a0010888:	e59f7184 	ldr	r7, [pc, #388]	; a0010a14 <fifo_open+0x43c>   <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
a001088c:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a0010890:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
        rtems_build_name ('P', 'I', 'r', c),                          
a0010894:	e5d70000 	ldrb	r0, [r7]                                     <== NOT EXECUTED
  if (! pipe->Buffer)                                                 
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
a0010898:	e285302c 	add	r3, r5, #44	; 0x2c                            <== NOT EXECUTED
a001089c:	e3800205 	orr	r0, r0, #1342177280	; 0x50000000              <== NOT EXECUTED
a00108a0:	e3800849 	orr	r0, r0, #4784128	; 0x490000                   <== NOT EXECUTED
a00108a4:	e3800c72 	orr	r0, r0, #29184	; 0x7200                       <== NOT EXECUTED
a00108a8:	eb0003f5 	bl	a0011884 <rtems_barrier_create>                <== NOT EXECUTED
a00108ac:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a00108b0:	1a00004c 	bne	a00109e8 <fifo_open+0x410>                    <== NOT EXECUTED
        rtems_build_name ('P', 'I', 'r', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->readBarrier) != RTEMS_SUCCESSFUL)                      
    goto err_rbar;                                                    
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'w', c),                          
a00108b4:	e5d70000 	ldrb	r0, [r7]                                     <== NOT EXECUTED
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'r', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->readBarrier) != RTEMS_SUCCESSFUL)                      
    goto err_rbar;                                                    
  if (rtems_barrier_create(                                           
a00108b8:	e2853030 	add	r3, r5, #48	; 0x30                            <== NOT EXECUTED
a00108bc:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a00108c0:	e3800205 	orr	r0, r0, #1342177280	; 0x50000000              <== NOT EXECUTED
a00108c4:	e3800849 	orr	r0, r0, #4784128	; 0x490000                   <== NOT EXECUTED
a00108c8:	e3800c77 	orr	r0, r0, #30464	; 0x7700                       <== NOT EXECUTED
a00108cc:	eb0003ec 	bl	a0011884 <rtems_barrier_create>                <== NOT EXECUTED
a00108d0:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a00108d4:	1a000041 	bne	a00109e0 <fifo_open+0x408>                    <== NOT EXECUTED
        rtems_build_name ('P', 'I', 'w', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->writeBarrier) != RTEMS_SUCCESSFUL)                     
    goto err_wbar;                                                    
  if (rtems_semaphore_create(                                         
        rtems_build_name ('P', 'I', 's', c), 1,                       
a00108d8:	e5d70000 	ldrb	r0, [r7]                                     <== NOT EXECUTED
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'w', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->writeBarrier) != RTEMS_SUCCESSFUL)                     
    goto err_wbar;                                                    
  if (rtems_semaphore_create(                                         
a00108dc:	e285c028 	add	ip, r5, #40	; 0x28                            <== NOT EXECUTED
a00108e0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00108e4:	e3800205 	orr	r0, r0, #1342177280	; 0x50000000              <== NOT EXECUTED
a00108e8:	e3800849 	orr	r0, r0, #4784128	; 0x490000                   <== NOT EXECUTED
a00108ec:	e3800c73 	orr	r0, r0, #29440	; 0x7300                       <== NOT EXECUTED
a00108f0:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
a00108f4:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00108f8:	ebffec31 	bl	a000b9c4 <rtems_semaphore_create>              <== NOT EXECUTED
a00108fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010900:	1a000034 	bne	a00109d8 <fifo_open+0x400>                    <== NOT EXECUTED
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
a0010904:	e5d73000 	ldrb	r3, [r7]                                     <== NOT EXECUTED
a0010908:	e353007a 	cmp	r3, #122	; 0x7a                               <== NOT EXECUTED
a001090c:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
    c = 'a';                                                          
a0010910:	03a03061 	moveq	r3, #97	; 0x61                              <== NOT EXECUTED
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
a0010914:	e5c72000 	strb	r2, [r7]                                     <== NOT EXECUTED
    c = 'a';                                                          
a0010918:	05c73000 	strbeq	r3, [r7]                                   <== NOT EXECUTED
a001091c:	eaffff3e 	b	a001061c <fifo_open+0x44>                       <== NOT EXECUTED
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
    if (err)                                                          
a0010920:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0010924:	1a00001b 	bne	a0010998 <fifo_open+0x3c0>                    <== NOT EXECUTED
      pipe_free(pipe);                                                
    else                                                              
      *pipep = pipe;                                                  
a0010928:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
out:                                                                  
  pipe_unlock();                                                      
a001092c:	ebfffeef 	bl	a00104f0 <pipe_unlock>                         <== NOT EXECUTED
a0010930:	eaffff46 	b	a0010650 <fifo_open+0x78>                       <== NOT EXECUTED
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
    rtems_libio_lock();                                               
                                                                      
    if (pipe_semaphore == RTEMS_ID_NONE) {                            
      sc = rtems_semaphore_create(                                    
a0010934:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a0010938:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a001093c:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
a0010940:	e59f00d0 	ldr	r0, [pc, #208]	; a0010a18 <fifo_open+0x440>   <== NOT EXECUTED
a0010944:	e58d5000 	str	r5, [sp]                                      <== NOT EXECUTED
a0010948:	ebffec1d 	bl	a000b9c4 <rtems_semaphore_create>              <== NOT EXECUTED
a001094c:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0010950:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a0010954:	ebffecfd 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
a0010958:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a001095c:	0a000028 	beq	a0010a04 <fifo_open+0x42c>                    <== NOT EXECUTED
)                                                                     
{                                                                     
  pipe_control_t *pipe;                                               
  int err = 0;                                                        
                                                                      
  err = pipe_lock();                                                  
a0010960:	e3e0700b 	mvn	r7, #11                                       <== NOT EXECUTED
a0010964:	eaffff45 	b	a0010680 <fifo_open+0xa8>                       <== NOT EXECUTED
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
a0010968:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a001096c:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a0010970:	eb000421 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010974:	eaffff58 	b	a00106dc <fifo_open+0x104>                      <== NOT EXECUTED
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
a0010978:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a001097c:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a0010980:	eb00041d 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010984:	eaffff98 	b	a00107ec <fifo_open+0x214>                      <== NOT EXECUTED
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
a0010988:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a001098c:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a0010990:	eb000419 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010994:	eaffff74 	b	a001076c <fifo_open+0x194>                      <== NOT EXECUTED
/* Called with pipe_semaphore held. */                                
static inline void pipe_free(                                         
  pipe_control_t *pipe                                                
)                                                                     
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
a0010998:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a001099c:	eb0003ea 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
  rtems_barrier_delete(pipe->writeBarrier);                           
a00109a0:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a00109a4:	eb0003e8 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
  rtems_semaphore_delete(pipe->Semaphore);                            
a00109a8:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a00109ac:	ebffec75 	bl	a000bb88 <rtems_semaphore_delete>              <== NOT EXECUTED
  free(pipe->Buffer);                                                 
a00109b0:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a00109b4:	ebffdd69 	bl	a0007f60 <free>                                <== NOT EXECUTED
  free(pipe);                                                         
a00109b8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00109bc:	ebffdd67 	bl	a0007f60 <free>                                <== NOT EXECUTED
    else                                                              
      *pipep = pipe;                                                  
  }                                                                   
                                                                      
out:                                                                  
  pipe_unlock();                                                      
a00109c0:	ebfffeca 	bl	a00104f0 <pipe_unlock>                         <== NOT EXECUTED
a00109c4:	eaffff2d 	b	a0010680 <fifo_open+0xa8>                       <== NOT EXECUTED
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
	PIPE_UNLOCK(pipe);                                                   
a00109c8:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a00109cc:	ebffecdf 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
        err = -ENXIO;                                                 
a00109d0:	e3e07005 	mvn	r7, #5                                        <== NOT EXECUTED
        goto out_error;                                               
a00109d4:	eaffff58 	b	a001073c <fifo_open+0x164>                      <== NOT EXECUTED
  if (c ++ == 'z')                                                    
    c = 'a';                                                          
  return 0;                                                           
                                                                      
err_sem:                                                              
  rtems_barrier_delete(pipe->writeBarrier);                           
a00109d8:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a00109dc:	eb0003da 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
err_wbar:                                                             
  rtems_barrier_delete(pipe->readBarrier);                            
a00109e0:	e598002c 	ldr	r0, [r8, #44]	; 0x2c                          <== NOT EXECUTED
a00109e4:	eb0003d8 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
err_rbar:                                                             
  free(pipe->Buffer);                                                 
a00109e8:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a00109ec:	ebffdd5b 	bl	a0007f60 <free>                                <== NOT EXECUTED
err_buf:                                                              
  free(pipe);                                                         
a00109f0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a00109f4:	ebffdd59 	bl	a0007f60 <free>                                <== NOT EXECUTED
)                                                                     
{                                                                     
  pipe_control_t *pipe;                                               
  int err = 0;                                                        
                                                                      
  err = pipe_lock();                                                  
a00109f8:	e3e0700b 	mvn	r7, #11                                       <== NOT EXECUTED
    else                                                              
      *pipep = pipe;                                                  
  }                                                                   
                                                                      
out:                                                                  
  pipe_unlock();                                                      
a00109fc:	ebfffebb 	bl	a00104f0 <pipe_unlock>                         <== NOT EXECUTED
a0010a00:	eaffff1e 	b	a0010680 <fifo_open+0xa8>                       <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
a0010a04:	e5958000 	ldr	r8, [r5]                                      <== NOT EXECUTED
a0010a08:	eafffefa 	b	a00105f8 <fifo_open+0x20>                       <== NOT EXECUTED
                                                                      

a000643c <flockfile>: #include <stdio.h> /* This is a non-functional stub */ void flockfile(FILE* file) { }
a000643c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006f7c <fpathconf>: { long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd);
a0006f7c:	e59f310c 	ldr	r3, [pc, #268]	; a0007090 <fpathconf+0x114>   <== NOT EXECUTED
                                                                      
long fpathconf(                                                       
  int   fd,                                                           
  int   name                                                          
)                                                                     
{                                                                     
a0006f80:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  long                                    return_value;               
  rtems_libio_t                          *iop;                        
  rtems_filesystem_limits_and_options_t  *the_limits;                 
                                                                      
  rtems_libio_check_fd(fd);                                           
a0006f84:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006f88:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0006f8c:	2a000035 	bcs	a0007068 <fpathconf+0xec>                     <== NOT EXECUTED
  iop = rtems_libio_iop(fd);                                          
a0006f90:	e59f30fc 	ldr	r3, [pc, #252]	; a0007094 <fpathconf+0x118>   <== NOT EXECUTED
a0006f94:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
a0006f98:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006f9c:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0006fa0:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a0006fa4:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0006fa8:	0a00002e 	beq	a0007068 <fpathconf+0xec>                     <== NOT EXECUTED
  rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);               
a0006fac:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a0006fb0:	0a000031 	beq	a000707c <fpathconf+0x100>                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;  
a0006fb4:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  switch ( name ) {                                                   
a0006fb8:	e351000b 	cmp	r1, #11                                       <== NOT EXECUTED
a0006fbc:	979ff101 	ldrls	pc, [pc, r1, lsl #2]                        <== NOT EXECUTED
a0006fc0:	ea00000d 	b	a0006ffc <fpathconf+0x80>                       <== NOT EXECUTED
a0006fc4:	a0007010 	.word	0xa0007010                                  <== NOT EXECUTED
a0006fc8:	a0007018 	.word	0xa0007018                                  <== NOT EXECUTED
a0006fcc:	a0007020 	.word	0xa0007020                                  <== NOT EXECUTED
a0006fd0:	a0007028 	.word	0xa0007028                                  <== NOT EXECUTED
a0006fd4:	a0007030 	.word	0xa0007030                                  <== NOT EXECUTED
a0006fd8:	a0007038 	.word	0xa0007038                                  <== NOT EXECUTED
a0006fdc:	a0007040 	.word	0xa0007040                                  <== NOT EXECUTED
a0006fe0:	a0007048 	.word	0xa0007048                                  <== NOT EXECUTED
a0006fe4:	a0007050 	.word	0xa0007050                                  <== NOT EXECUTED
a0006fe8:	a0007058 	.word	0xa0007058                                  <== NOT EXECUTED
a0006fec:	a0007060 	.word	0xa0007060                                  <== NOT EXECUTED
a0006ff0:	a0006ff4 	.word	0xa0006ff4                                  <== NOT EXECUTED
      break;                                                          
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
      break;                                                          
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
a0006ff4:	e5930060 	ldr	r0, [r3, #96]	; 0x60                          <== NOT EXECUTED
      break;                                                          
a0006ff8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0006ffc:	eb002c67 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0007000:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007004:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007008:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
a000700c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;  
                                                                      
  switch ( name ) {                                                   
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
a0007010:	e5930038 	ldr	r0, [r3, #56]	; 0x38                          <== NOT EXECUTED
      break;                                                          
a0007014:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
a0007018:	e593003c 	ldr	r0, [r3, #60]	; 0x3c                          <== NOT EXECUTED
      break;                                                          
a000701c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
a0007020:	e5930040 	ldr	r0, [r3, #64]	; 0x40                          <== NOT EXECUTED
      break;                                                          
a0007024:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
a0007028:	e5930044 	ldr	r0, [r3, #68]	; 0x44                          <== NOT EXECUTED
      break;                                                          
a000702c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
a0007030:	e5930048 	ldr	r0, [r3, #72]	; 0x48                          <== NOT EXECUTED
      break;                                                          
a0007034:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
a0007038:	e593004c 	ldr	r0, [r3, #76]	; 0x4c                          <== NOT EXECUTED
      break;                                                          
a000703c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
a0007040:	e5930054 	ldr	r0, [r3, #84]	; 0x54                          <== NOT EXECUTED
      break;                                                          
a0007044:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
a0007048:	e5930058 	ldr	r0, [r3, #88]	; 0x58                          <== NOT EXECUTED
      break;                                                          
a000704c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
a0007050:	e5930064 	ldr	r0, [r3, #100]	; 0x64                         <== NOT EXECUTED
      break;                                                          
a0007054:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
a0007058:	e5930050 	ldr	r0, [r3, #80]	; 0x50                          <== NOT EXECUTED
      break;                                                          
a000705c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
a0007060:	e593005c 	ldr	r0, [r3, #92]	; 0x5c                          <== NOT EXECUTED
      break;                                                          
a0007064:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  rtems_libio_t                          *iop;                        
  rtems_filesystem_limits_and_options_t  *the_limits;                 
                                                                      
  rtems_libio_check_fd(fd);                                           
  iop = rtems_libio_iop(fd);                                          
  rtems_libio_check_is_open(iop);                                     
a0007068:	eb002c4c 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a000706c:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0007070:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007074:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007078:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);               
a000707c:	eb002c47 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0007080:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007084:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007088:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000708c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0006374 <free>: void free( void *ptr ) { MSBUMP(free_calls, 1);
a0006374:	e59f3090 	ldr	r3, [pc, #144]	; a000640c <free+0x98>         <== NOT EXECUTED
#include <stdlib.h>                                                   
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
a0006378:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  MSBUMP(free_calls, 1);                                              
a000637c:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
                                                                      
  if ( !ptr )                                                         
a0006380:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
  MSBUMP(free_calls, 1);                                              
a0006384:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0006388:	e583200c 	str	r2, [r3, #12]                                 <== NOT EXECUTED
                                                                      
  if ( !ptr )                                                         
a000638c:	0a000010 	beq	a00063d4 <free+0x60>                          <== NOT EXECUTED
    return;                                                           
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a0006390:	e59f3078 	ldr	r3, [pc, #120]	; a0006410 <free+0x9c>         <== NOT EXECUTED
a0006394:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006398:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a000639c:	0a000014 	beq	a00063f4 <free+0x80>                          <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
a00063a0:	e59f306c 	ldr	r3, [pc, #108]	; a0006414 <free+0xa0>         <== NOT EXECUTED
a00063a4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00063a8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00063ac:	0a000002 	beq	a00063bc <free+0x48>                          <== NOT EXECUTED
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
a00063b0:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a00063b4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00063b8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
a00063bc:	e59f5054 	ldr	r5, [pc, #84]	; a0006418 <free+0xa4>          <== NOT EXECUTED
a00063c0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00063c4:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a00063c8:	eb00146d 	bl	a000b584 <_Protected_heap_Free>                <== NOT EXECUTED
a00063cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00063d0:	0a000000 	beq	a00063d8 <free+0x64>                          <== NOT EXECUTED
a00063d4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
      ptr,                                                            
      RTEMS_Malloc_Heap->area_begin,                                  
a00063d8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
a00063dc:	e59f0038 	ldr	r0, [pc, #56]	; a000641c <free+0xa8>          <== NOT EXECUTED
a00063e0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00063e4:	e5932018 	ldr	r2, [r3, #24]                                 <== NOT EXECUTED
a00063e8:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
      RTEMS_Malloc_Heap->area_begin,                                  
      RTEMS_Malloc_Heap->area_end                                     
    );                                                                
  }                                                                   
                                                                      
}                                                                     
a00063ec:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
a00063f0:	ea000386 	b	a0007210 <printk>                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() ) {                               
a00063f4:	eb000068 	bl	a000659c <malloc_is_system_state_OK>           <== NOT EXECUTED
    return;                                                           
                                                                      
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a00063f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00063fc:	1affffe7 	bne	a00063a0 <free+0x2c>                          <== NOT EXECUTED
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
a0006400:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
      RTEMS_Malloc_Heap->area_begin,                                  
      RTEMS_Malloc_Heap->area_end                                     
    );                                                                
  }                                                                   
                                                                      
}                                                                     
a0006404:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
  /*                                                                  
   *  Do not attempt to free memory if in a critical section or ISR.  
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
a0006408:	ea000080 	b	a0006610 <malloc_deferred_free>                 <== NOT EXECUTED
                                                                      

a00077d0 <free_user_env>: static void free_user_env(void *venv) { rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env
a00077d0:	e59f302c 	ldr	r3, [pc, #44]	; a0007804 <free_user_env+0x34> <== NOT EXECUTED
 * NOTE: this must be called with                                     
 *       thread dispatching disabled!                                 
 */                                                                   
static void                                                           
free_user_env(void *venv)                                             
{                                                                     
a00077d4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_user_env_t *env = (rtems_user_env_t*) venv ;                  
                                                                      
  if (env != &rtems_global_user_env                                   
a00077d8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
 * NOTE: this must be called with                                     
 *       thread dispatching disabled!                                 
 */                                                                   
static void                                                           
free_user_env(void *venv)                                             
{                                                                     
a00077dc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_user_env_t *env = (rtems_user_env_t*) venv ;                  
                                                                      
  if (env != &rtems_global_user_env                                   
a00077e0:	0a000006 	beq	a0007800 <free_user_env+0x30>                 <== NOT EXECUTED
  #ifdef HAVE_USERENV_REFCNT                                          
      && --env->refcnt <= 0                                           
  #endif                                                              
  ) {                                                                 
    rtems_filesystem_freenode( &env->current_directory);              
a00077e4:	e2800004 	add	r0, r0, #4                                    <== NOT EXECUTED
a00077e8:	ebfffb6f 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_filesystem_freenode( &env->root_directory);                 
a00077ec:	e2840018 	add	r0, r4, #24                                   <== NOT EXECUTED
a00077f0:	ebfffb6d 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
    free(env);                                                        
a00077f4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  }                                                                   
}                                                                     
a00077f8:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
      && --env->refcnt <= 0                                           
  #endif                                                              
  ) {                                                                 
    rtems_filesystem_freenode( &env->current_directory);              
    rtems_filesystem_freenode( &env->root_directory);                 
    free(env);                                                        
a00077fc:	eafffb6f 	b	a00065c0 <free>                                 <== NOT EXECUTED
a0007800:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0015e60 <fstat>: int fstat( int fd, struct stat *sbuf ) {
a0015e60:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
a0015e64:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
a0015e68:	0a000019 	beq	a0015ed4 <fstat+0x74>                         <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
a0015e6c:	e59f3074 	ldr	r3, [pc, #116]	; a0015ee8 <fstat+0x88>        <== NOT EXECUTED
a0015e70:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0015e74:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0015e78:	2a000010 	bcs	a0015ec0 <fstat+0x60>                         <== NOT EXECUTED
a0015e7c:	e59f3068 	ldr	r3, [pc, #104]	; a0015eec <fstat+0x8c>        <== NOT EXECUTED
a0015e80:	e3a05038 	mov	r5, #56	; 0x38                                <== NOT EXECUTED
a0015e84:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0015e88:	e0253590 	mla	r5, r0, r5, r3                                <== NOT EXECUTED
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
a0015e8c:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a0015e90:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0015e94:	0a000009 	beq	a0015ec0 <fstat+0x60>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
a0015e98:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0015e9c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0015ea0:	e3a02048 	mov	r2, #72	; 0x48                                <== NOT EXECUTED
a0015ea4:	ebffeef2 	bl	a0011a74 <memset>                              <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );  
a0015ea8:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0015eac:	e2850018 	add	r0, r5, #24                                   <== NOT EXECUTED
a0015eb0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0015eb4:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0015eb8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a0015ebc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
a0015ec0:	ebffec86 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0015ec4:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0015ec8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0015ecc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0015ed0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0015ed4:	ebffec81 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0015ed8:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a0015edc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0015ee0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0015ee4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a00071f4 <fsync>: int fd ) { rtems_libio_t *iop; rtems_libio_check_fd( fd );
a00071f4:	e59f3068 	ldr	r3, [pc, #104]	; a0007264 <fsync+0x70>        <== NOT EXECUTED
#include <rtems/seterr.h>                                             
                                                                      
int fsync(                                                            
  int     fd                                                          
)                                                                     
{                                                                     
a00071f8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a00071fc:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007200:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0007204:	2a00000c 	bcs	a000723c <fsync+0x48>                         <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0007208:	e59f3058 	ldr	r3, [pc, #88]	; a0007268 <fsync+0x74>         <== NOT EXECUTED
a000720c:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
a0007210:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0007214:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0007218:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a000721c:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0007220:	0a000005 	beq	a000723c <fsync+0x48>                         <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0007224:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a0007228:	0a000008 	beq	a0007250 <fsync+0x5c>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the fsync().                                        
   */                                                                 
                                                                      
  return (*iop->pathinfo.handlers->fsync_h)( iop );                   
a000722c:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
a0007230:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          <== NOT EXECUTED
a0007234:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a0007238:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
{                                                                     
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a000723c:	eb002bd7 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0007240:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0007244:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007248:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000724c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a0007250:	eb002bd2 	bl	a00121a0 <__errno>                             <== NOT EXECUTED
a0007254:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007258:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000725c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007260:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000e430 <ftruncate>: ) { rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd );
a000e430:	e59f30cc 	ldr	r3, [pc, #204]	; a000e504 <ftruncate+0xd4>    <== NOT EXECUTED
                                                                      
int ftruncate(                                                        
  int     fd,                                                         
  off_t   length                                                      
)                                                                     
{                                                                     
a000e434:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
a000e438:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
                                                                      
int ftruncate(                                                        
  int     fd,                                                         
  off_t   length                                                      
)                                                                     
{                                                                     
a000e43c:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
a000e440:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
a000e444:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
                                                                      
int ftruncate(                                                        
  int     fd,                                                         
  off_t   length                                                      
)                                                                     
{                                                                     
a000e448:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
a000e44c:	2a00001d 	bcs	a000e4c8 <ftruncate+0x98>                     <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a000e450:	e59f30b0 	ldr	r3, [pc, #176]	; a000e508 <ftruncate+0xd8>    <== NOT EXECUTED
a000e454:	e3a04038 	mov	r4, #56	; 0x38                                <== NOT EXECUTED
a000e458:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000e45c:	e0243490 	mla	r4, r0, r4, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a000e460:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a000e464:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a000e468:	0a000016 	beq	a000e4c8 <ftruncate+0x98>                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
a000e46c:	e1a0c00d 	mov	ip, sp                                        <== NOT EXECUTED
a000e470:	e284e018 	add	lr, r4, #24                                   <== NOT EXECUTED
a000e474:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000e478:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000e47c:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
a000e480:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
a000e484:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
a000e488:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a000e48c:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000e490:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000e494:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000e498:	0a000014 	beq	a000e4f0 <ftruncate+0xc0>                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EISDIR );                   
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a000e49c:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a000e4a0:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a000e4a4:	0a00000c 	beq	a000e4dc <ftruncate+0xac>                     <== NOT EXECUTED
                                                                      
  return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );       
a000e4a8:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a000e4ac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e4b0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000e4b4:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000e4b8:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
a000e4bc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a000e4c0:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a000e4c4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  rtems_libio_t                    *iop;                              
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a000e4c8:	eb000b04 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e4cc:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a000e4d0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e4d4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000e4d8:	eafffff8 	b	a000e4c0 <ftruncate+0x90>                       <== NOT EXECUTED
                                                                      
  loc = iop->pathinfo;                                                
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
    rtems_set_errno_and_return_minus_one( EISDIR );                   
                                                                      
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a000e4dc:	eb000aff 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e4e0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000e4e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e4e8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000e4ec:	eafffff3 	b	a000e4c0 <ftruncate+0x90>                       <== NOT EXECUTED
   *  Make sure we are not working on a directory                     
   */                                                                 
                                                                      
  loc = iop->pathinfo;                                                
  if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
    rtems_set_errno_and_return_minus_one( EISDIR );                   
a000e4f0:	eb000afa 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e4f4:	e3a03015 	mov	r3, #21                                       <== NOT EXECUTED
a000e4f8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e4fc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000e500:	eaffffee 	b	a000e4c0 <ftruncate+0x90>                       <== NOT EXECUTED
                                                                      

a0006500 <ftrylockfile>: #include <rtems/seterr.h> #include <errno.h> /* This is a non-functional stub */ int ftrylockfile(FILE* file) {
a0006500:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( ENOTSUP );                    
a0006504:	eb002afb 	bl	a00110f8 <__errno>                             <== NOT EXECUTED
a0006508:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
a000650c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
}                                                                     
a0006510:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006514:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0006518 <funlockfile>: #include <stdio.h> /* This is a non-functional stub */ void funlockfile(FILE* file) { }
a0006518:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00178e8 <getdents>: rtems_filesystem_location_info_t loc; /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd );
a00178e8:	e59f308c 	ldr	r3, [pc, #140]	; a001797c <getdents+0x94>     <== NOT EXECUTED
int getdents(                                                         
  int   dd_fd,                                                        
  char *dd_buf,                                                       
  int   dd_len                                                        
)                                                                     
{                                                                     
a00178ec:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
  iop = rtems_libio_iop( dd_fd );                                     
a00178f0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int getdents(                                                         
  int   dd_fd,                                                        
  char *dd_buf,                                                       
  int   dd_len                                                        
)                                                                     
{                                                                     
a00178f4:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
  iop = rtems_libio_iop( dd_fd );                                     
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
a00178f8:	e1a0c00d 	mov	ip, sp                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
  iop = rtems_libio_iop( dd_fd );                                     
a00178fc:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0017900:	359f3078 	ldrcc	r3, [pc, #120]	; a0017980 <getdents+0x98>   <== NOT EXECUTED
a0017904:	33a04038 	movcc	r4, #56	; 0x38                              <== NOT EXECUTED
a0017908:	23a04000 	movcs	r4, #0                                      <== NOT EXECUTED
a001790c:	35933000 	ldrcc	r3, [r3]                                    <== NOT EXECUTED
int getdents(                                                         
  int   dd_fd,                                                        
  char *dd_buf,                                                       
  int   dd_len                                                        
)                                                                     
{                                                                     
a0017910:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a0017914:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
                                                                      
  /*                                                                  
   *  Get the file control block structure associated with the file descriptor
   */                                                                 
  iop = rtems_libio_iop( dd_fd );                                     
a0017918:	30243490 	mlacc	r4, r0, r4, r3                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
a001791c:	e284e018 	add	lr, r4, #24                                   <== NOT EXECUTED
a0017920:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0017924:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0017928:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
a001792c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
  iop = rtems_libio_iop( dd_fd );                                     
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
a0017930:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
a0017934:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0017938:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a001793c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0017940:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0017944:	1a000007 	bne	a0017968 <getdents+0x80>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Return the number of bytes that were actually transfered as a result
   *  of the read attempt.                                            
   */                                                                 
  return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len  );   
a0017948:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a001794c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0017950:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0017954:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0017958:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a001795c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
}                                                                     
a0017960:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a0017964:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  loc = iop->pathinfo;                                                
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a0017968:	ebffe93b 	bl	a0011e5c <__errno>                             <== NOT EXECUTED
a001796c:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a0017970:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0017974:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0017978:	eafffff8 	b	a0017960 <getdents+0x78>                        <== NOT EXECUTED
                                                                      

a00069f0 <getegid>: * P1003.1b-1993, p. 84 */ gid_t getegid( void ) { return _POSIX_types_Egid;
a00069f0:	e59f3008 	ldr	r3, [pc, #8]	; a0006a00 <getegid+0x10>        <== NOT EXECUTED
a00069f4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
}                                                                     
a00069f8:	e1d303b8 	ldrh	r0, [r3, #56]	; 0x38                         <== NOT EXECUTED
a00069fc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006a04 <geteuid>: * P1003.1b-1993, p. 84 */ uid_t geteuid( void ) { return _POSIX_types_Euid;
a0006a04:	e59f3008 	ldr	r3, [pc, #8]	; a0006a14 <geteuid+0x10>        <== NOT EXECUTED
a0006a08:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
}                                                                     
a0006a0c:	e1d303b6 	ldrh	r0, [r3, #54]	; 0x36                         <== NOT EXECUTED
a0006a10:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006a18 <getgid>: * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { return _POSIX_types_Gid;
a0006a18:	e59f3008 	ldr	r3, [pc, #8]	; a0006a28 <getgid+0x10>         <== NOT EXECUTED
a0006a1c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
}                                                                     
a0006a20:	e1d303b4 	ldrh	r0, [r3, #52]	; 0x34                         <== NOT EXECUTED
a0006a24:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007040 <getgr_r>: struct group *grp, char *buffer, size_t bufsize, struct group **result ) {
a0007040:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a0007044:	e59d801c 	ldr	r8, [sp, #28]                                 <== NOT EXECUTED
a0007048:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000704c:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
a0007050:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a0007054:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  FILE *fp;                                                           
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
a0007058:	ebffffbf 	bl	a0006f5c <init_etc_passwd_group>               <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/group", "r")) == NULL)                        
a000705c:	e59f00b0 	ldr	r0, [pc, #176]	; a0007114 <getgr_r+0xd4>      <== NOT EXECUTED
a0007060:	e59f10b0 	ldr	r1, [pc, #176]	; a0007118 <getgr_r+0xd8>      <== NOT EXECUTED
a0007064:	eb002e4e 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0007068:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a000706c:	1a000006 	bne	a000708c <getgr_r+0x4c>                       <== NOT EXECUTED
a0007070:	ea000022 	b	a0007100 <getgr_r+0xc0>                         <== NOT EXECUTED
  for(;;) {                                                           
    if (!scangr(fp, grp, buffer, bufsize))                            
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
      match = (strcmp(grp->gr_name, name) == 0);                      
a0007074:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0007078:	eb0031fa 	bl	a0013868 <strcmp>                              <== NOT EXECUTED
a000707c:	e2700001 	rsbs	r0, r0, #1                                   <== NOT EXECUTED
a0007080:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
    } else {                                                          
      match = (grp->gr_gid == gid);                                   
    }                                                                 
                                                                      
    if (match) {                                                      
a0007084:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007088:	1a00000f 	bne	a00070cc <getgr_r+0x8c>                       <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/group", "r")) == NULL)                        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for(;;) {                                                           
    if (!scangr(fp, grp, buffer, bufsize))                            
a000708c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0007090:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0007094:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a0007098:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000709c:	ebffff0f 	bl	a0006ce0 <scangr>                              <== NOT EXECUTED
a00070a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
      match = (strcmp(grp->gr_name, name) == 0);                      
a00070a4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/group", "r")) == NULL)                        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for(;;) {                                                           
    if (!scangr(fp, grp, buffer, bufsize))                            
a00070a8:	0a00000d 	beq	a00070e4 <getgr_r+0xa4>                       <== NOT EXECUTED
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
a00070ac:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a00070b0:	1affffef 	bne	a0007074 <getgr_r+0x34>                       <== NOT EXECUTED
      match = (strcmp(grp->gr_name, name) == 0);                      
    } else {                                                          
      match = (grp->gr_gid == gid);                                   
a00070b4:	e1d400b8 	ldrh	r0, [r4, #8]                                 <== NOT EXECUTED
a00070b8:	e150000a 	cmp	r0, sl                                        <== NOT EXECUTED
a00070bc:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a00070c0:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    if (match) {                                                      
a00070c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00070c8:	0affffef 	beq	a000708c <getgr_r+0x4c>                       <== NOT EXECUTED
      fclose(fp);                                                     
a00070cc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00070d0:	eb002c5c 	bl	a0012248 <fclose>                              <== NOT EXECUTED
      *result = grp;                                                  
a00070d4:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
      return 0;                                                       
a00070d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      match = (grp->gr_gid == gid);                                   
    }                                                                 
                                                                      
    if (match) {                                                      
      fclose(fp);                                                     
      *result = grp;                                                  
a00070dc:	e5834000 	str	r4, [r3]                                      <== NOT EXECUTED
      return 0;                                                       
a00070e0:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
error_einval:                                                         
  fclose(fp);                                                         
a00070e4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00070e8:	eb002c56 	bl	a0012248 <fclose>                              <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( EINVAL );                     
a00070ec:	eb002c07 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a00070f0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00070f4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00070f8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00070fc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
                                                                      
  if ((fp = fopen("/etc/group", "r")) == NULL)                        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0007100:	eb002c02 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a0007104:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007108:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000710c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007110:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a0007454 <getgrent>: struct group *getgrent(void) {
a0007454:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if (group_fp == NULL)                                               
a0007458:	e59f4028 	ldr	r4, [pc, #40]	; a0007488 <getgrent+0x34>      <== NOT EXECUTED
a000745c:	e59401c4 	ldr	r0, [r4, #452]	; 0x1c4                        <== NOT EXECUTED
a0007460:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007464:	1a000000 	bne	a000746c <getgrent+0x18>                      <== NOT EXECUTED
    return NULL;                                                      
  if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))                 
    return NULL;                                                      
  return &grent;                                                      
}                                                                     
a0007468:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
struct group *getgrent(void)                                          
{                                                                     
  if (group_fp == NULL)                                               
    return NULL;                                                      
  if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))                 
a000746c:	e28410ec 	add	r1, r4, #236	; 0xec                           <== NOT EXECUTED
a0007470:	e28420fc 	add	r2, r4, #252	; 0xfc                           <== NOT EXECUTED
a0007474:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a0007478:	ebfffe18 	bl	a0006ce0 <scangr>                              <== NOT EXECUTED
    return NULL;                                                      
a000747c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007480:	128400ec 	addne	r0, r4, #236	; 0xec                         <== NOT EXECUTED
  return &grent;                                                      
}                                                                     
a0007484:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0007414 <getgrgid>: struct group *getgrgid( gid_t gid ) {
a0007414:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))                
a0007418:	e59f1030 	ldr	r1, [pc, #48]	; a0007450 <getgrgid+0x3c>      <== NOT EXECUTED
}                                                                     
                                                                      
struct group *getgrgid(                                               
  gid_t gid                                                           
)                                                                     
{                                                                     
a000741c:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
a0007420:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))                
a0007424:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a0007428:	e2812010 	add	r2, r1, #16                                   <== NOT EXECUTED
a000742c:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a0007430:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
a0007434:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0007438:	ebffffe6 	bl	a00073d8 <getgrgid_r>                          <== NOT EXECUTED
a000743c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
a0007440:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
)                                                                     
{                                                                     
  struct group *p;                                                    
                                                                      
  if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))                
    return NULL;                                                      
a0007444:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
  return p;                                                           
}                                                                     
a0007448:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000744c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a00073d8 <getgrgid_r>: struct group *grp, char *buffer, size_t bufsize, struct group **result ) {
a00073d8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a00073dc:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
a00073e0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a00073e4:	e1a04800 	lsl	r4, r0, #16                                   <== NOT EXECUTED
  return getgr_r(NULL, gid, grp, buffer, bufsize, result);            
a00073e8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a00073ec:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a00073f0:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
  struct group   *grp,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct group  **result                                              
)                                                                     
{                                                                     
a00073f4:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getgr_r(NULL, gid, grp, buffer, bufsize, result);            
a00073f8:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
a00073fc:	e1a01824 	lsr	r1, r4, #16                                   <== NOT EXECUTED
a0007400:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007404:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a0007408:	ebffff0c 	bl	a0007040 <getgr_r>                             <== NOT EXECUTED
}                                                                     
a000740c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0007410:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a00073a0 <getgrnam>: struct group *getgrnam( const char *name ) {
a00073a0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))               
a00073a4:	e59f1028 	ldr	r1, [pc, #40]	; a00073d4 <getgrnam+0x34>      <== NOT EXECUTED
}                                                                     
                                                                      
struct group *getgrnam(                                               
  const char *name                                                    
)                                                                     
{                                                                     
a00073a8:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  struct group *p;                                                    
                                                                      
  if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))               
a00073ac:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a00073b0:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a00073b4:	e2812010 	add	r2, r1, #16                                   <== NOT EXECUTED
a00073b8:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00073bc:	ebffffea 	bl	a000736c <getgrnam_r>                          <== NOT EXECUTED
a00073c0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
a00073c4:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
)                                                                     
{                                                                     
  struct group *p;                                                    
                                                                      
  if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))               
    return NULL;                                                      
a00073c8:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
  return p;                                                           
}                                                                     
a00073cc:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a00073d0:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000736c <getgrnam_r>: struct group *grp, char *buffer, size_t bufsize, struct group **result ) {
a000736c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0007370:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
a0007374:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  return getgr_r(name, 0, grp, buffer, bufsize, result);              
a0007378:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000737c:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a0007380:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
  struct group   *grp,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct group  **result                                              
)                                                                     
{                                                                     
a0007384:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getgr_r(name, 0, grp, buffer, bufsize, result);              
a0007388:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
a000738c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0007390:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a0007394:	ebffff29 	bl	a0007040 <getgr_r>                             <== NOT EXECUTED
}                                                                     
a0007398:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000739c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a0006a2c <getgroups>: int gidsetsize __attribute__((unused)), gid_t grouplist[] __attribute__((unused)) ) { return 0; /* no supplemental group ids */ }
a0006a2c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006a30:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006a84 <getlogin>: * 4.2.4 Get User Name, P1003.1b-1993, p. 87 * * NOTE: P1003.1c/D10, p. 49 adds getlogin_r(). */ char *getlogin( void ) {
a0006a84:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  (void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );  
a0006a88:	e59f4018 	ldr	r4, [pc, #24]	; a0006aa8 <getlogin+0x24>      <== NOT EXECUTED
a0006a8c:	e3a01009 	mov	r1, #9                                        <== NOT EXECUTED
a0006a90:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0006a94:	e280003a 	add	r0, r0, #58	; 0x3a                            <== NOT EXECUTED
a0006a98:	ebffffe5 	bl	a0006a34 <getlogin_r>                          <== NOT EXECUTED
  return _POSIX_types_Getlogin_buffer;                                
a0006a9c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
}                                                                     
a0006aa0:	e280003a 	add	r0, r0, #58	; 0x3a                            <== NOT EXECUTED
a0006aa4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0006a34 <getlogin_r>: */ int getlogin_r( char *name, size_t namesize ) {
a0006a34:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  struct passwd *pw;                                                  
  char          *pname;                                               
                                                                      
  if ( !name )                                                        
a0006a38:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0006a3c:	0a00000d 	beq	a0006a78 <getlogin_r+0x44>                    <== NOT EXECUTED
    return EFAULT;                                                    
                                                                      
  if ( namesize < LOGIN_NAME_MAX )                                    
a0006a40:	e3510008 	cmp	r1, #8                                        <== NOT EXECUTED
a0006a44:	8a000001 	bhi	a0006a50 <getlogin_r+0x1c>                    <== NOT EXECUTED
    return ERANGE;                                                    
a0006a48:	e3a00022 	mov	r0, #34	; 0x22                                <== NOT EXECUTED
  if ( pw )                                                           
   pname = pw->pw_name;                                               
                                                                      
  strncpy( name, pname, LOGIN_NAME_MAX );                             
  return 0;                                                           
}                                                                     
a0006a4c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
    return ERANGE;                                                    
                                                                      
  /* Set the pointer to a default name */                             
  pname = "";                                                         
                                                                      
  pw = getpwuid(getuid());                                            
a0006a50:	eb0002c0 	bl	a0007558 <getuid>                              <== NOT EXECUTED
a0006a54:	eb000211 	bl	a00072a0 <getpwuid>                            <== NOT EXECUTED
  if ( pw )                                                           
a0006a58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
   pname = pw->pw_name;                                               
a0006a5c:	15901000 	ldrne	r1, [r0]                                    <== NOT EXECUTED
                                                                      
  if ( namesize < LOGIN_NAME_MAX )                                    
    return ERANGE;                                                    
                                                                      
  /* Set the pointer to a default name */                             
  pname = "";                                                         
a0006a60:	059f1018 	ldreq	r1, [pc, #24]	; a0006a80 <getlogin_r+0x4c>  <== NOT EXECUTED
                                                                      
  pw = getpwuid(getuid());                                            
  if ( pw )                                                           
   pname = pw->pw_name;                                               
                                                                      
  strncpy( name, pname, LOGIN_NAME_MAX );                             
a0006a64:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006a68:	e3a02009 	mov	r2, #9                                        <== NOT EXECUTED
a0006a6c:	eb003471 	bl	a0013c38 <strncpy>                             <== NOT EXECUTED
  return 0;                                                           
a0006a70:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006a74:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
{                                                                     
  struct passwd *pw;                                                  
  char          *pname;                                               
                                                                      
  if ( !name )                                                        
    return EFAULT;                                                    
a0006a78:	e3a0000e 	mov	r0, #14                                       <== NOT EXECUTED
a0006a7c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0006aac <getpgrp>: * This always succeeds and returns the process group id. For rtems, * this will always be the local node; */ return _Objects_Local_node; }
a0006aac:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0006ab0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0025a0c <getpid>: */ pid_t getpid( void ) { return _Objects_Local_node; }
a0025a0c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0025a10:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006ac8 <getppid>: * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getppid( void ) {
a0006ac8:	e59f3004 	ldr	r3, [pc, #4]	; a0006ad4 <getppid+0xc>         <== NOT EXECUTED
  return _POSIX_types_Ppid;                                           
}                                                                     
a0006acc:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a0006ad0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000711c <getpw_r>: struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) {
a000711c:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a0007120:	e59d801c 	ldr	r8, [sp, #28]                                 <== NOT EXECUTED
a0007124:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0007128:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
a000712c:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a0007130:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  FILE *fp;                                                           
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
a0007134:	ebffff88 	bl	a0006f5c <init_etc_passwd_group>               <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/passwd", "r")) == NULL)                       
a0007138:	e59f00b0 	ldr	r0, [pc, #176]	; a00071f0 <getpw_r+0xd4>      <== NOT EXECUTED
a000713c:	e59f10b0 	ldr	r1, [pc, #176]	; a00071f4 <getpw_r+0xd8>      <== NOT EXECUTED
a0007140:	eb002e17 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0007144:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0007148:	1a000006 	bne	a0007168 <getpw_r+0x4c>                       <== NOT EXECUTED
a000714c:	ea000022 	b	a00071dc <getpw_r+0xc0>                         <== NOT EXECUTED
  for(;;) {                                                           
    if (!scanpw(fp, pwd, buffer, bufsize))                            
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
      match = (strcmp(pwd->pw_name, name) == 0);                      
a0007150:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0007154:	eb0031c3 	bl	a0013868 <strcmp>                              <== NOT EXECUTED
a0007158:	e2700001 	rsbs	r0, r0, #1                                   <== NOT EXECUTED
a000715c:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
    } else {                                                          
      match = (pwd->pw_uid == uid);                                   
    }                                                                 
                                                                      
    if (match) {                                                      
a0007160:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007164:	1a00000f 	bne	a00071a8 <getpw_r+0x8c>                       <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/passwd", "r")) == NULL)                       
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for(;;) {                                                           
    if (!scanpw(fp, pwd, buffer, bufsize))                            
a0007168:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000716c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0007170:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a0007174:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007178:	ebffff2e 	bl	a0006e38 <scanpw>                              <== NOT EXECUTED
a000717c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
      match = (strcmp(pwd->pw_name, name) == 0);                      
a0007180:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
                                                                      
  if ((fp = fopen("/etc/passwd", "r")) == NULL)                       
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  for(;;) {                                                           
    if (!scanpw(fp, pwd, buffer, bufsize))                            
a0007184:	0a00000d 	beq	a00071c0 <getpw_r+0xa4>                       <== NOT EXECUTED
      goto error_einval;                                              
                                                                      
    if (name) {                                                       
a0007188:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000718c:	1affffef 	bne	a0007150 <getpw_r+0x34>                       <== NOT EXECUTED
      match = (strcmp(pwd->pw_name, name) == 0);                      
    } else {                                                          
      match = (pwd->pw_uid == uid);                                   
a0007190:	e1d400b8 	ldrh	r0, [r4, #8]                                 <== NOT EXECUTED
a0007194:	e150000a 	cmp	r0, sl                                        <== NOT EXECUTED
a0007198:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a000719c:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    if (match) {                                                      
a00071a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00071a4:	0affffef 	beq	a0007168 <getpw_r+0x4c>                       <== NOT EXECUTED
      fclose(fp);                                                     
a00071a8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00071ac:	eb002c25 	bl	a0012248 <fclose>                              <== NOT EXECUTED
      *result = pwd;                                                  
a00071b0:	e59d3020 	ldr	r3, [sp, #32]                                 <== NOT EXECUTED
      return 0;                                                       
a00071b4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
      match = (pwd->pw_uid == uid);                                   
    }                                                                 
                                                                      
    if (match) {                                                      
      fclose(fp);                                                     
      *result = pwd;                                                  
a00071b8:	e5834000 	str	r4, [r3]                                      <== NOT EXECUTED
      return 0;                                                       
a00071bc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
error_einval:                                                         
  fclose(fp);                                                         
a00071c0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00071c4:	eb002c1f 	bl	a0012248 <fclose>                              <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( EINVAL );                     
a00071c8:	eb002bd0 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a00071cc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00071d0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00071d4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00071d8:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  int match;                                                          
                                                                      
  init_etc_passwd_group();                                            
                                                                      
  if ((fp = fopen("/etc/passwd", "r")) == NULL)                       
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a00071dc:	eb002bcb 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a00071e0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00071e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00071e8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00071ec:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a00072e0 <getpwent>: struct passwd *getpwent(void) {
a00072e0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if (passwd_fp == NULL)                                              
a00072e4:	e59f4028 	ldr	r4, [pc, #40]	; a0007314 <getpwent+0x34>      <== NOT EXECUTED
a00072e8:	e59400e8 	ldr	r0, [r4, #232]	; 0xe8                         <== NOT EXECUTED
a00072ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00072f0:	1a000000 	bne	a00072f8 <getpwent+0x18>                      <== NOT EXECUTED
    return NULL;                                                      
  if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))                
    return NULL;                                                      
  return &pwent;                                                      
}                                                                     
a00072f4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
struct passwd *getpwent(void)                                         
{                                                                     
  if (passwd_fp == NULL)                                              
    return NULL;                                                      
  if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))                
a00072f8:	e2841004 	add	r1, r4, #4                                    <== NOT EXECUTED
a00072fc:	e2842020 	add	r2, r4, #32                                   <== NOT EXECUTED
a0007300:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a0007304:	ebfffecb 	bl	a0006e38 <scanpw>                              <== NOT EXECUTED
    return NULL;                                                      
a0007308:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000730c:	12840004 	addne	r0, r4, #4                                  <== NOT EXECUTED
  return &pwent;                                                      
}                                                                     
a0007310:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000722c <getpwnam>: struct passwd *getpwnam( const char *name ) {
a000722c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))               
a0007230:	e59f1028 	ldr	r1, [pc, #40]	; a0007260 <getpwnam+0x34>      <== NOT EXECUTED
}                                                                     
                                                                      
struct passwd *getpwnam(                                              
  const char *name                                                    
)                                                                     
{                                                                     
a0007234:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))               
a0007238:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a000723c:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a0007240:	e281201c 	add	r2, r1, #28                                   <== NOT EXECUTED
a0007244:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0007248:	ebffffea 	bl	a00071f8 <getpwnam_r>                          <== NOT EXECUTED
a000724c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
a0007250:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
)                                                                     
{                                                                     
  struct passwd *p;                                                   
                                                                      
  if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))               
    return NULL;                                                      
a0007254:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
  return p;                                                           
}                                                                     
a0007258:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000725c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a00071f8 <getpwnam_r>: struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) {
a00071f8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00071fc:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
a0007200:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  return getpw_r(name, 0, pwd, buffer, bufsize, result);              
a0007204:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0007208:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a000720c:	e59dc00c 	ldr	ip, [sp, #12]                                 <== NOT EXECUTED
  struct passwd  *pwd,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct passwd **result                                              
)                                                                     
{                                                                     
a0007210:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getpw_r(name, 0, pwd, buffer, bufsize, result);              
a0007214:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
a0007218:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000721c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a0007220:	ebffffbd 	bl	a000711c <getpw_r>                             <== NOT EXECUTED
}                                                                     
a0007224:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0007228:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a00072a0 <getpwuid>: struct passwd *getpwuid( uid_t uid ) {
a00072a0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))                
a00072a4:	e59f1030 	ldr	r1, [pc, #48]	; a00072dc <getpwuid+0x3c>      <== NOT EXECUTED
}                                                                     
                                                                      
struct passwd *getpwuid(                                              
  uid_t uid                                                           
)                                                                     
{                                                                     
a00072a8:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
a00072ac:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  struct passwd *p;                                                   
                                                                      
  if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))                
a00072b0:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a00072b4:	e281201c 	add	r2, r1, #28                                   <== NOT EXECUTED
a00072b8:	e3a030c8 	mov	r3, #200	; 0xc8                               <== NOT EXECUTED
a00072bc:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
a00072c0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00072c4:	ebffffe6 	bl	a0007264 <getpwuid_r>                          <== NOT EXECUTED
a00072c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return NULL;                                                      
  return p;                                                           
a00072cc:	059d0004 	ldreq	r0, [sp, #4]                                <== NOT EXECUTED
)                                                                     
{                                                                     
  struct passwd *p;                                                   
                                                                      
  if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))                
    return NULL;                                                      
a00072d0:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
  return p;                                                           
}                                                                     
a00072d4:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a00072d8:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a0007264 <getpwuid_r>: struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) {
a0007264:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a0007268:	e1a0c002 	mov	ip, r2                                        <== NOT EXECUTED
a000726c:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0007270:	e1a04800 	lsl	r4, r0, #16                                   <== NOT EXECUTED
  return getpw_r(NULL, uid, pwd, buffer, bufsize, result);            
a0007274:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0007278:	e1a0300c 	mov	r3, ip                                        <== NOT EXECUTED
a000727c:	e59dc010 	ldr	ip, [sp, #16]                                 <== NOT EXECUTED
  struct passwd  *pwd,                                                
  char           *buffer,                                             
  size_t          bufsize,                                            
  struct passwd **result                                              
)                                                                     
{                                                                     
a0007280:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
  return getpw_r(NULL, uid, pwd, buffer, bufsize, result);            
a0007284:	e1a0200e 	mov	r2, lr                                        <== NOT EXECUTED
a0007288:	e1a01824 	lsr	r1, r4, #16                                   <== NOT EXECUTED
a000728c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007290:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a0007294:	ebffffa0 	bl	a000711c <getpw_r>                             <== NOT EXECUTED
}                                                                     
a0007298:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000729c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000670c <getrusage>: #include <rtems.h> #include <rtems/seterr.h> int getrusage(int who, struct rusage *usage) {
a000670c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  struct timespec uptime;                                             
  struct timeval  rtime;                                              
                                                                      
  if ( !usage )                                                       
a0006710:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
#include <rtems.h>                                                    
#include <rtems/seterr.h>                                             
                                                                      
int getrusage(int who, struct rusage *usage)                          
{                                                                     
a0006714:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0006718:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  struct timespec uptime;                                             
  struct timeval  rtime;                                              
                                                                      
  if ( !usage )                                                       
a000671c:	0a00001c 	beq	a0006794 <getrusage+0x88>                     <== NOT EXECUTED
   *  RTEMS only has a single process so there are no children.       
   *  The single process has been running since the system            
   *  was booted and since there is no distinction between system     
   *  and user time, we will just report the uptime.                  
   */                                                                 
  if (who == RUSAGE_SELF) {                                           
a0006720:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006724:	0a00000c 	beq	a000675c <getrusage+0x50>                     <== NOT EXECUTED
    usage->ru_stime = rtime;                                          
                                                                      
    return 0;                                                         
  }                                                                   
                                                                      
  if (who == RUSAGE_CHILDREN) {                                       
a0006728:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a000672c:	0a000005 	beq	a0006748 <getrusage+0x3c>                     <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
a0006730:	eb002b1b 	bl	a00113a4 <__errno>                             <== NOT EXECUTED
a0006734:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006738:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000673c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0006740:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0006744:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
    return 0;                                                         
  }                                                                   
                                                                      
  if (who == RUSAGE_CHILDREN) {                                       
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
a0006748:	eb002b15 	bl	a00113a4 <__errno>                             <== NOT EXECUTED
a000674c:	e3a03058 	mov	r3, #88	; 0x58                                <== NOT EXECUTED
a0006750:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006754:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006758:	eafffff8 	b	a0006740 <getrusage+0x34>                       <== NOT EXECUTED
   *  The single process has been running since the system            
   *  was booted and since there is no distinction between system     
   *  and user time, we will just report the uptime.                  
   */                                                                 
  if (who == RUSAGE_SELF) {                                           
    rtems_clock_get_uptime( &uptime );                                
a000675c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0006760:	eb000bfe 	bl	a0009760 <rtems_clock_get_uptime>              <== NOT EXECUTED
                                                                      
    rtime.tv_sec  = uptime.tv_sec;                                    
    rtime.tv_usec = uptime.tv_nsec / 1000;                            
a0006764:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
a0006768:	e59f3038 	ldr	r3, [pc, #56]	; a00067a8 <getrusage+0x9c>     <== NOT EXECUTED
   *  and user time, we will just report the uptime.                  
   */                                                                 
  if (who == RUSAGE_SELF) {                                           
    rtems_clock_get_uptime( &uptime );                                
                                                                      
    rtime.tv_sec  = uptime.tv_sec;                                    
a000676c:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
    rtime.tv_usec = uptime.tv_nsec / 1000;                            
a0006770:	e1a00fc1 	asr	r0, r1, #31                                   <== NOT EXECUTED
a0006774:	e0c3c391 	smull	ip, r3, r1, r3                              <== NOT EXECUTED
a0006778:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
a000677c:	e0603343 	rsb	r3, r0, r3, asr #6                            <== NOT EXECUTED
a0006780:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
a0006784:	e5852008 	str	r2, [r5, #8]                                  <== NOT EXECUTED
a0006788:	e585300c 	str	r3, [r5, #12]                                 <== NOT EXECUTED
                                                                      
    usage->ru_utime = rtime;                                          
    usage->ru_stime = rtime;                                          
                                                                      
    return 0;                                                         
a000678c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006790:	eaffffea 	b	a0006740 <getrusage+0x34>                       <== NOT EXECUTED
{                                                                     
  struct timespec uptime;                                             
  struct timeval  rtime;                                              
                                                                      
  if ( !usage )                                                       
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0006794:	eb002b02 	bl	a00113a4 <__errno>                             <== NOT EXECUTED
a0006798:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a000679c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00067a0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00067a4:	eaffffe5 	b	a0006740 <getrusage+0x34>                       <== NOT EXECUTED
                                                                      

a0006448 <gettimeofday>: */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) {
a0006448:	e92d4030 	push	{r4, r5, lr}                                 
  /* struct timezone* tzp = (struct timezone*) __tz; */               
  if ( !tp )                                                          
a000644c:	e2504000 	subs	r4, r0, #0                                   
 */                                                                   
int gettimeofday(                                                     
  struct timeval  *tp,                                                
  void * __tz __attribute__((unused))                                 
)                                                                     
{                                                                     
a0006450:	e24dd008 	sub	sp, sp, #8                                    
  /* struct timezone* tzp = (struct timezone*) __tz; */               
  if ( !tp )                                                          
a0006454:	0a00000f 	beq	a0006498 <gettimeofday+0x50>                  
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0006458:	e10f5000 	mrs	r5, CPSR                                      
a000645c:	e3853080 	orr	r3, r5, #128	; 0x80                           
a0006460:	e129f003 	msr	CPSR_fc, r3                                   
  ISR_Level       level;                                              
  struct timespec now;                                                
  suseconds_t     useconds;                                           
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
a0006464:	e1a0000d 	mov	r0, sp                                        
a0006468:	eb0010ee 	bl	a000a828 <_TOD_Get>                            
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000646c:	e129f005 	msr	CPSR_fc, r5                                   
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a0006470:	e59f2034 	ldr	r2, [pc, #52]	; a00064ac <gettimeofday+0x64>  
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
a0006474:	e59d3004 	ldr	r3, [sp, #4]                                  
   *  Timezone information ignored by the OS proper.   Per email      
   *  with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X    
   *  do it.  This puts us in good company.                           
   */                                                                 
                                                                      
  return 0;                                                           
a0006478:	e3a00000 	mov	r0, #0                                        
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a000647c:	e0c21293 	smull	r1, r2, r3, r2                              
a0006480:	e1a03fc3 	asr	r3, r3, #31                                   
a0006484:	e0633342 	rsb	r3, r3, r2, asr #6                            
                                                                      
  time->tv_sec  = now.tv_sec;                                         
a0006488:	e59d2000 	ldr	r2, [sp]                                      
  time->tv_usec = useconds;                                           
a000648c:	e884000c 	stm	r4, {r2, r3}                                  
}                                                                     
a0006490:	e28dd008 	add	sp, sp, #8                                    
a0006494:	e8bd8030 	pop	{r4, r5, pc}                                  
  void * __tz __attribute__((unused))                                 
)                                                                     
{                                                                     
  /* struct timezone* tzp = (struct timezone*) __tz; */               
  if ( !tp )                                                          
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0006498:	eb002b10 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000649c:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a00064a0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00064a4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00064a8:	eafffff8 	b	a0006490 <gettimeofday+0x48>                    <== NOT EXECUTED
                                                                      

a0007558 <getuid>: * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { return _POSIX_types_Uid;
a0007558:	e59f3008 	ldr	r3, [pc, #8]	; a0007568 <getuid+0x10>         <== NOT EXECUTED
a000755c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
}                                                                     
a0007560:	e1d303b2 	ldrh	r0, [r3, #50]	; 0x32                         <== NOT EXECUTED
a0007564:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a001097c <imfs_dir_close>: * and associated memory. At present the imfs_dir_close simply * returns a successful completion status. */ return 0; }
a001097c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010980:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00109f0 <imfs_dir_fstat>: rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) loc->node_access;
a00109f0:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
                                                                      
int imfs_dir_fstat(                                                   
  rtems_filesystem_location_info_t *loc,                              
  struct stat                      *buf                               
)                                                                     
{                                                                     
a00109f4:	e92d01f0 	push	{r4, r5, r6, r7, r8}                         <== NOT EXECUTED
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
   buf->st_ino   = the_jnode->st_ino;                                 
   buf->st_mode  = the_jnode->st_mode;                                
   buf->st_nlink = the_jnode->st_nlink;                               
a00109f8:	e1d323b4 	ldrh	r2, [r3, #52]	; 0x34                         <== NOT EXECUTED
   buf->st_gid   = the_jnode->st_gid;                                 
   buf->st_rdev = 0ll;                                                
   buf->st_blksize = 0;                                               
   buf->st_blocks = 0;                                                
   buf->st_atime = the_jnode->stat_atime;                             
   buf->st_mtime = the_jnode->stat_mtime;                             
a00109fc:	e593c044 	ldr	ip, [r3, #68]	; 0x44                          <== NOT EXECUTED
   buf->st_ctime = the_jnode->stat_ctime;                             
a0010a00:	e5930048 	ldr	r0, [r3, #72]	; 0x48                          <== NOT EXECUTED
                                                                      
                                                                      
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
   buf->st_ino   = the_jnode->st_ino;                                 
a0010a04:	e5938038 	ldr	r8, [r3, #56]	; 0x38                          <== NOT EXECUTED
   buf->st_mode  = the_jnode->st_mode;                                
a0010a08:	e5937030 	ldr	r7, [r3, #48]	; 0x30                          <== NOT EXECUTED
   buf->st_uid   = the_jnode->st_uid;                                 
   buf->st_gid   = the_jnode->st_gid;                                 
   buf->st_rdev = 0ll;                                                
   buf->st_blksize = 0;                                               
   buf->st_blocks = 0;                                                
   buf->st_atime = the_jnode->stat_atime;                             
a0010a0c:	e5936040 	ldr	r6, [r3, #64]	; 0x40                          <== NOT EXECUTED
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
   buf->st_ino   = the_jnode->st_ino;                                 
   buf->st_mode  = the_jnode->st_mode;                                
   buf->st_nlink = the_jnode->st_nlink;                               
a0010a10:	e1c121b0 	strh	r2, [r1, #16]                                <== NOT EXECUTED
   buf->st_uid   = the_jnode->st_uid;                                 
a0010a14:	e1d323bc 	ldrh	r2, [r3, #60]	; 0x3c                         <== NOT EXECUTED
   IMFS_jnode_t        *the_jnode;                                    
                                                                      
                                                                      
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
a0010a18:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a0010a1c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
   buf->st_ino   = the_jnode->st_ino;                                 
   buf->st_mode  = the_jnode->st_mode;                                
   buf->st_nlink = the_jnode->st_nlink;                               
   buf->st_uid   = the_jnode->st_uid;                                 
a0010a20:	e1c121b2 	strh	r2, [r1, #18]                                <== NOT EXECUTED
   buf->st_gid   = the_jnode->st_gid;                                 
a0010a24:	e1d323be 	ldrh	r2, [r3, #62]	; 0x3e                         <== NOT EXECUTED
   IMFS_jnode_t        *the_jnode;                                    
                                                                      
                                                                      
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
a0010a28:	e8810030 	stm	r1, {r4, r5}                                  <== NOT EXECUTED
   buf->st_ino   = the_jnode->st_ino;                                 
   buf->st_mode  = the_jnode->st_mode;                                
   buf->st_nlink = the_jnode->st_nlink;                               
   buf->st_uid   = the_jnode->st_uid;                                 
   buf->st_gid   = the_jnode->st_gid;                                 
   buf->st_rdev = 0ll;                                                
a0010a2c:	e5814018 	str	r4, [r1, #24]                                 <== NOT EXECUTED
a0010a30:	e581501c 	str	r5, [r1, #28]                                 <== NOT EXECUTED
   buf->st_blocks = 0;                                                
   buf->st_atime = the_jnode->stat_atime;                             
   buf->st_mtime = the_jnode->stat_mtime;                             
   buf->st_ctime = the_jnode->stat_ctime;                             
                                                                      
   buf->st_size = 0;                                                  
a0010a34:	e5814020 	str	r4, [r1, #32]                                 <== NOT EXECUTED
a0010a38:	e5815024 	str	r5, [r1, #36]	; 0x24                          <== NOT EXECUTED
   buf->st_dev = 0ll;                                                 
   buf->st_ino   = the_jnode->st_ino;                                 
   buf->st_mode  = the_jnode->st_mode;                                
   buf->st_nlink = the_jnode->st_nlink;                               
   buf->st_uid   = the_jnode->st_uid;                                 
   buf->st_gid   = the_jnode->st_gid;                                 
a0010a3c:	e1c121b4 	strh	r2, [r1, #20]                                <== NOT EXECUTED
   buf->st_rdev = 0ll;                                                
   buf->st_blksize = 0;                                               
a0010a40:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
   buf->st_blocks = 0;                                                
   buf->st_atime = the_jnode->stat_atime;                             
   buf->st_mtime = the_jnode->stat_mtime;                             
a0010a44:	e581c030 	str	ip, [r1, #48]	; 0x30                          <== NOT EXECUTED
                                                                      
                                                                      
   the_jnode = (IMFS_jnode_t *) loc->node_access;                     
                                                                      
   buf->st_dev = 0ll;                                                 
   buf->st_ino   = the_jnode->st_ino;                                 
a0010a48:	e5818008 	str	r8, [r1, #8]                                  <== NOT EXECUTED
   buf->st_mode  = the_jnode->st_mode;                                
a0010a4c:	e581700c 	str	r7, [r1, #12]                                 <== NOT EXECUTED
   buf->st_nlink = the_jnode->st_nlink;                               
   buf->st_uid   = the_jnode->st_uid;                                 
   buf->st_gid   = the_jnode->st_gid;                                 
   buf->st_rdev = 0ll;                                                
   buf->st_blksize = 0;                                               
a0010a50:	e5812040 	str	r2, [r1, #64]	; 0x40                          <== NOT EXECUTED
   buf->st_blocks = 0;                                                
a0010a54:	e5812044 	str	r2, [r1, #68]	; 0x44                          <== NOT EXECUTED
   buf->st_atime = the_jnode->stat_atime;                             
a0010a58:	e5816028 	str	r6, [r1, #40]	; 0x28                          <== NOT EXECUTED
   buf->st_mtime = the_jnode->stat_mtime;                             
   buf->st_ctime = the_jnode->stat_ctime;                             
a0010a5c:	e5810038 	str	r0, [r1, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  IMFS_create_orphan( the_jnode );                                    
  IMFS_check_node_remove( the_jnode );                                
                                                                      
  return 0;                                                           
}                                                                     
a0010a60:	e5930050 	ldr	r0, [r3, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(                             
  Chain_Control *the_chain,                                           
  const Chain_Node    *the_node                                       
)                                                                     
{                                                                     
  return (the_node == _Chain_Tail(the_chain));                        
a0010a64:	e283c054 	add	ip, r3, #84	; 0x54                            <== NOT EXECUTED
                                                                      
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Run through the chain and count the number of directory entries */
   /* that are subordinate to this directory node                     */
   for ( the_node = rtems_chain_first( the_chain );                   
a0010a68:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
a0010a6c:	0a00000c 	beq	a0010aa4 <imfs_dir_fstat+0xb4>                <== NOT EXECUTED
a0010a70:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
a0010a74:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
         !rtems_chain_is_tail( the_chain, the_node ) ;                
         the_node = the_node->next ) {                                
a0010a78:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
a0010a7c:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
a0010a80:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
                                                                      
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Run through the chain and count the number of directory entries */
   /* that are subordinate to this directory node                     */
   for ( the_node = rtems_chain_first( the_chain );                   
a0010a84:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
         !rtems_chain_is_tail( the_chain, the_node ) ;                
         the_node = the_node->next ) {                                
a0010a88:	e0922006 	adds	r2, r2, r6                                   <== NOT EXECUTED
                                                                      
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Run through the chain and count the number of directory entries */
   /* that are subordinate to this directory node                     */
   for ( the_node = rtems_chain_first( the_chain );                   
a0010a8c:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
         !rtems_chain_is_tail( the_chain, the_node ) ;                
         the_node = the_node->next ) {                                
a0010a90:	e0a33007 	adc	r3, r3, r7                                    <== NOT EXECUTED
                                                                      
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   /* Run through the chain and count the number of directory entries */
   /* that are subordinate to this directory node                     */
   for ( the_node = rtems_chain_first( the_chain );                   
a0010a94:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
a0010a98:	1afffff8 	bne	a0010a80 <imfs_dir_fstat+0x90>                <== NOT EXECUTED
a0010a9c:	e5815020 	str	r5, [r1, #32]                                 <== NOT EXECUTED
a0010aa0:	e5814024 	str	r4, [r1, #36]	; 0x24                          <== NOT EXECUTED
                                                                      
      buf->st_size = buf->st_size + sizeof( struct dirent );          
   }                                                                  
                                                                      
   return 0;                                                          
}                                                                     
a0010aa4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010aa8:	e8bd01f0 	pop	{r4, r5, r6, r7, r8}                          <== NOT EXECUTED
a0010aac:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010984 <imfs_dir_lseek>: rtems_libio_t *iop, rtems_off64_t offset, int whence ) { switch( whence ) {
a0010984:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
rtems_off64_t imfs_dir_lseek(                                         
  rtems_libio_t  *iop,                                                
  rtems_off64_t   offset,                                             
  int             whence                                              
)                                                                     
{                                                                     
a0010988:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a001098c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  switch( whence ) {                                                  
a0010990:	9a000007 	bls	a00109b4 <imfs_dir_lseek+0x30>                <== NOT EXECUTED
        break;                                                        
                                                                      
     case SEEK_END:   /* Movement past the end of the directory via lseek */
                      /* is not a permitted operation                     */
      default:                                                        
        rtems_set_errno_and_return_minus_one( EINVAL );               
a0010994:	eb0001d1 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0010998:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a001099c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00109a0:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a00109a4:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
        break;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a00109a8:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a00109ac:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a00109b0:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
)                                                                     
{                                                                     
  switch( whence ) {                                                  
     case SEEK_SET:   /* absolute move from the start of the file */  
     case SEEK_CUR:   /* relative move */                             
        iop->offset = (iop->offset/sizeof(struct dirent)) *           
a00109b4:	e280100c 	add	r1, r0, #12                                   <== NOT EXECUTED
a00109b8:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
a00109bc:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
a00109c0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00109c4:	eb001002 	bl	a00149d4 <__divdi3>                            <== NOT EXECUTED
a00109c8:	e3a0ce11 	mov	ip, #272	; 0x110                              <== NOT EXECUTED
a00109cc:	e0865c90 	umull	r5, r6, r0, ip                              <== NOT EXECUTED
      default:                                                        
        rtems_set_errno_and_return_minus_one( EINVAL );               
        break;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
a00109d0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  switch( whence ) {                                                  
     case SEEK_SET:   /* absolute move from the start of the file */  
     case SEEK_CUR:   /* relative move */                             
        iop->offset = (iop->offset/sizeof(struct dirent)) *           
a00109d4:	e026619c 	mla	r6, ip, r1, r6                                <== NOT EXECUTED
      default:                                                        
        rtems_set_errno_and_return_minus_one( EINVAL );               
        break;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
a00109d8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  switch( whence ) {                                                  
     case SEEK_SET:   /* absolute move from the start of the file */  
     case SEEK_CUR:   /* relative move */                             
        iop->offset = (iop->offset/sizeof(struct dirent)) *           
a00109dc:	e584500c 	str	r5, [r4, #12]                                 <== NOT EXECUTED
a00109e0:	e5846010 	str	r6, [r4, #16]                                 <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EINVAL );               
        break;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
a00109e4:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a00109e8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a00109ec:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a001080c <imfs_dir_open>: IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access; if ( the_jnode->type != IMFS_DIRECTORY )
a001080c:	e5903018 	ldr	r3, [r0, #24]                                 <== NOT EXECUTED
  rtems_libio_t  *iop,                                                
  const char *pathname,                                               
  uint32_t   flag,                                                    
  uint32_t   mode                                                     
)                                                                     
{                                                                     
a0010810:	e52d4004 	push	{r4}		; (str r4, [sp, #-4]!)                 <== NOT EXECUTED
  IMFS_jnode_t      *the_jnode;                                       
                                                                      
  /* Is the node a directory ? */                                     
  the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;             
                                                                      
  if ( the_jnode->type != IMFS_DIRECTORY )                            
a0010814:	e593304c 	ldr	r3, [r3, #76]	; 0x4c                          <== NOT EXECUTED
a0010818:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
     return -1;      /* It wasn't a directory --> return error */     
a001081c:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
  IMFS_jnode_t      *the_jnode;                                       
                                                                      
  /* Is the node a directory ? */                                     
  the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;             
                                                                      
  if ( the_jnode->type != IMFS_DIRECTORY )                            
a0010820:	1a000004 	bne	a0010838 <imfs_dir_open+0x2c>                 <== NOT EXECUTED
     return -1;      /* It wasn't a directory --> return error */     
                                                                      
  iop->offset = 0;                                                    
a0010824:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010828:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a001082c:	e580300c 	str	r3, [r0, #12]                                 <== NOT EXECUTED
a0010830:	e5804010 	str	r4, [r0, #16]                                 <== NOT EXECUTED
  return 0;                                                           
a0010834:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010838:	e8bd0010 	pop	{r4}                                          <== NOT EXECUTED
a001083c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010840 <imfs_dir_read>: ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) {
a0010840:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
   int                  current_entry;                                
   int                  first_entry;                                  
   int                  last_entry;                                   
   struct dirent        tmp_dirent;                                   
                                                                      
   the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;             
a0010844:	e5908018 	ldr	r8, [r0, #24]                                 <== NOT EXECUTED
ssize_t imfs_dir_read(                                                
  rtems_libio_t  *iop,                                                
  void           *buffer,                                             
  size_t          count                                               
)                                                                     
{                                                                     
a0010848:	e24dde12 	sub	sp, sp, #288	; 0x120                          <== NOT EXECUTED
a001084c:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
                                                                      
  IMFS_create_orphan( the_jnode );                                    
  IMFS_check_node_remove( the_jnode );                                
                                                                      
  return 0;                                                           
}                                                                     
a0010850:	e5985050 	ldr	r5, [r8, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a0010854:	e2888054 	add	r8, r8, #84	; 0x54                            <== NOT EXECUTED
ssize_t imfs_dir_read(                                                
  rtems_libio_t  *iop,                                                
  void           *buffer,                                             
  size_t          count                                               
)                                                                     
{                                                                     
a0010858:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
   struct dirent        tmp_dirent;                                   
                                                                      
   the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;             
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   if ( rtems_chain_is_empty( the_chain ) )                           
a001085c:	e1550008 	cmp	r5, r8                                        <== NOT EXECUTED
a0010860:	0a000042 	beq	a0010970 <imfs_dir_read+0x130>                <== NOT EXECUTED
                                                                      
   bytes_transferred = 0;                                             
   first_entry = iop->offset;                                         
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
a0010864:	e59f710c 	ldr	r7, [pc, #268]	; a0010978 <imfs_dir_read+0x138><== NOT EXECUTED
                                                                      
   /* Move to the first of the desired directory entries */           
   the_node = rtems_chain_first( the_chain );                         
                                                                      
   bytes_transferred = 0;                                             
   first_entry = iop->offset;                                         
a0010868:	e590600c 	ldr	r6, [r0, #12]                                 <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
a001086c:	e0820297 	umull	r0, r2, r7, r2                              <== NOT EXECUTED
a0010870:	e3a07e11 	mov	r7, #272	; 0x110                              <== NOT EXECUTED
a0010874:	e1a02422 	lsr	r2, r2, #8                                    <== NOT EXECUTED
a0010878:	e0276792 	mla	r7, r2, r7, r6                                <== NOT EXECUTED
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a001087c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0010880:	da00003a 	ble	a0010970 <imfs_dir_read+0x130>                <== NOT EXECUTED
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a0010884:	e3e01c01 	mvn	r1, #256	; 0x100                              <== NOT EXECUTED
         strcpy( tmp_dirent.d_name, the_jnode->name );                
a0010888:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a001088c:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
      }                                                               
                                                                      
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
a0010890:	e3a0b4bf 	mov	fp, #-1090519040	; 0xbf000000                 <== NOT EXECUTED
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a0010894:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
         strcpy( tmp_dirent.d_name, the_jnode->name );                
a0010898:	e2822010 	add	r2, r2, #16                                   <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a001089c:	e1a0a004 	mov	sl, r4                                        <== NOT EXECUTED
      }                                                               
                                                                      
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
a00108a0:	e1a0bb4b 	asr	fp, fp, #22                                   <== NOT EXECUTED
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a00108a4:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
         strcpy( tmp_dirent.d_name, the_jnode->name );                
a00108a8:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
a00108ac:	ea000005 	b	a00108c8 <imfs_dir_read+0x88>                   <== NOT EXECUTED
 *  to the end of the exisiting file, the remaining entries will be placed in
 *  the buffer and the returned value will be equal to -m actual- times the
 *  size of a directory entry.                                        
 */                                                                   
                                                                      
ssize_t imfs_dir_read(                                                
a00108b0:	e2844e11 	add	r4, r4, #272	; 0x110                          <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a00108b4:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
         );                                                           
         iop->offset = iop->offset + sizeof(struct dirent);           
         bytes_transferred = bytes_transferred + sizeof( struct dirent );
      }                                                               
                                                                      
      the_node = the_node->next;                                      
a00108b8:	e5955000 	ldr	r5, [r5]                                      <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a00108bc:	da000028 	ble	a0010964 <imfs_dir_read+0x124>                <== NOT EXECUTED
      current_entry = 0;                                              
      current_entry < last_entry;                                     
      current_entry = current_entry + sizeof(struct dirent) ){        
                                                                      
      if ( rtems_chain_is_tail( the_chain, the_node ) ){              
a00108c0:	e1550008 	cmp	r5, r8                                        <== NOT EXECUTED
a00108c4:	0a000026 	beq	a0010964 <imfs_dir_read+0x124>                <== NOT EXECUTED
         /* entry in the read */                                      
         return bytes_transferred;  /* Indicate that there are no more */
                                    /* entries to return */           
      }                                                               
                                                                      
      if( current_entry >= first_entry ) {                            
a00108c8:	e1560004 	cmp	r6, r4                                        <== NOT EXECUTED
a00108cc:	cafffff7 	bgt	a00108b0 <imfs_dir_read+0x70>                 <== NOT EXECUTED
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
a00108d0:	e595c038 	ldr	ip, [r5, #56]	; 0x38                          <== NOT EXECUTED
                                    /* entries to return */           
      }                                                               
                                                                      
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
a00108d4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a00108d8:	e1a03fc2 	asr	r3, r2, #31                                   <== NOT EXECUTED
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a00108dc:	e285100c 	add	r1, r5, #12                                   <== NOT EXECUTED
                                    /* entries to return */           
      }                                                               
                                                                      
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
a00108e0:	e58d2014 	str	r2, [sp, #20]                                 <== NOT EXECUTED
a00108e4:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
         tmp_dirent.d_reclen = sizeof( struct dirent );               
a00108e8:	e3a03e11 	mov	r3, #272	; 0x110                              <== NOT EXECUTED
a00108ec:	e28d2e12 	add	r2, sp, #288	; 0x120                          <== NOT EXECUTED
a00108f0:	e18230bb 	strh	r3, [r2, fp]                                 <== NOT EXECUTED
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a00108f4:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
      if( current_entry >= first_entry ) {                            
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
a00108f8:	e58dc010 	str	ip, [sp, #16]                                 <== NOT EXECUTED
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a00108fc:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a0010900:	eb0005e0 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a0010904:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0010908:	e28d2e12 	add	r2, sp, #288	; 0x120                          <== NOT EXECUTED
         strcpy( tmp_dirent.d_name, the_jnode->name );                
a001090c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
         /* Move the entry to the return buffer */                    
         tmp_dirent.d_off = current_entry;                            
         tmp_dirent.d_reclen = sizeof( struct dirent );               
         the_jnode = (IMFS_jnode_t *) the_node;                       
         tmp_dirent.d_ino = the_jnode->st_ino;                        
         tmp_dirent.d_namlen = strlen( the_jnode->name );             
a0010910:	e18200b3 	strh	r0, [r2, r3]                                 <== NOT EXECUTED
         strcpy( tmp_dirent.d_name, the_jnode->name );                
a0010914:	e59d000c 	ldr	r0, [sp, #12]                                 <== NOT EXECUTED
a0010918:	eb00058a 	bl	a0011f48 <strcpy>                              <== NOT EXECUTED
         memcpy(                                                      
a001091c:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0010920:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
a0010924:	e3a02e11 	mov	r2, #272	; 0x110                              <== NOT EXECUTED
a0010928:	e083000a 	add	r0, r3, sl                                    <== NOT EXECUTED
a001092c:	eb000419 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset = iop->offset + sizeof(struct dirent);           
a0010930:	e289300c 	add	r3, r9, #12                                   <== NOT EXECUTED
a0010934:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0010938:	e3a00e11 	mov	r0, #272	; 0x110                              <== NOT EXECUTED
a001093c:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
a0010940:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
 *  to the end of the exisiting file, the remaining entries will be placed in
 *  the buffer and the returned value will be equal to -m actual- times the
 *  size of a directory entry.                                        
 */                                                                   
                                                                      
ssize_t imfs_dir_read(                                                
a0010944:	e2844e11 	add	r4, r4, #272	; 0x110                          <== NOT EXECUTED
         memcpy(                                                      
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset = iop->offset + sizeof(struct dirent);           
a0010948:	e0a33001 	adc	r3, r3, r1                                    <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a001094c:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
         memcpy(                                                      
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset = iop->offset + sizeof(struct dirent);           
a0010950:	e589200c 	str	r2, [r9, #12]                                 <== NOT EXECUTED
a0010954:	e5893010 	str	r3, [r9, #16]                                 <== NOT EXECUTED
         bytes_transferred = bytes_transferred + sizeof( struct dirent );
a0010958:	e28aae11 	add	sl, sl, #272	; 0x110                          <== NOT EXECUTED
      }                                                               
                                                                      
      the_node = the_node->next;                                      
a001095c:	e5955000 	ldr	r5, [r5]                                      <== NOT EXECUTED
   /* protect against using sizes that are not exact multiples of the */
   /* -dirent- size. These could result in unexpected results          */
   last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
a0010960:	caffffd6 	bgt	a00108c0 <imfs_dir_read+0x80>                 <== NOT EXECUTED
      current_entry = 0;                                              
      current_entry < last_entry;                                     
      current_entry = current_entry + sizeof(struct dirent) ){        
                                                                      
      if ( rtems_chain_is_tail( the_chain, the_node ) ){              
a0010964:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
      the_node = the_node->next;                                      
   }                                                                  
                                                                      
   /* Success */                                                      
   return bytes_transferred;                                          
}                                                                     
a0010968:	e28dde12 	add	sp, sp, #288	; 0x120                          <== NOT EXECUTED
a001096c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
   the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;             
   the_chain = &the_jnode->info.directory.Entries;                    
                                                                      
   if ( rtems_chain_is_empty( the_chain ) )                           
      return 0;                                                       
a0010970:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010974:	eafffffb 	b	a0010968 <imfs_dir_read+0x128>                  <== NOT EXECUTED
                                                                      

a0010ab0 <imfs_dir_rmnod>: int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) {
a0010ab0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_jnode_t *the_jnode;                                            
                                                                      
  the_jnode = (IMFS_jnode_t *) pathloc->node_access;                  
a0010ab4:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * You cannot remove a node that still has children                 
   */                                                                 
                                                                      
  if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 
a0010ab8:	e5942050 	ldr	r2, [r4, #80]	; 0x50                          <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
a0010abc:	e2843054 	add	r3, r4, #84	; 0x54                            <== NOT EXECUTED
a0010ac0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0010ac4:	1a000011 	bne	a0010b10 <imfs_dir_rmnod+0x60>                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * You cannot remove the file system root node.                     
   */                                                                 
                                                                      
  if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
a0010ac8:	e5913010 	ldr	r3, [r1, #16]                                 <== NOT EXECUTED
a0010acc:	e593301c 	ldr	r3, [r3, #28]                                 <== NOT EXECUTED
a0010ad0:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a0010ad4:	0a000008 	beq	a0010afc <imfs_dir_rmnod+0x4c>                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * You cannot remove a mountpoint.                                  
   */                                                                 
                                                                      
   if ( the_jnode->info.directory.mt_fs != NULL )                     
a0010ad8:	e594505c 	ldr	r5, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0010adc:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0010ae0:	1a000005 	bne	a0010afc <imfs_dir_rmnod+0x4c>                <== NOT EXECUTED
     rtems_set_errno_and_return_minus_one( EBUSY );                   
                                                                      
  IMFS_create_orphan( the_jnode );                                    
a0010ae4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010ae8:	ebfff5bf 	bl	a000e1ec <IMFS_create_orphan>                  <== NOT EXECUTED
  IMFS_check_node_remove( the_jnode );                                
a0010aec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010af0:	ebfff5d0 	bl	a000e238 <IMFS_check_node_remove>              <== NOT EXECUTED
                                                                      
  return 0;                                                           
a0010af4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
}                                                                     
a0010af8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   * You cannot remove a mountpoint.                                  
   */                                                                 
                                                                      
   if ( the_jnode->info.directory.mt_fs != NULL )                     
     rtems_set_errno_and_return_minus_one( EBUSY );                   
a0010afc:	eb000177 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0010b00:	e3a03010 	mov	r3, #16                                       <== NOT EXECUTED
a0010b04:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0010b08:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0010b0c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   * You cannot remove a node that still has children                 
   */                                                                 
                                                                      
  if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 
     rtems_set_errno_and_return_minus_one( ENOTEMPTY );               
a0010b10:	eb000172 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0010b14:	e3a0305a 	mov	r3, #90	; 0x5a                                <== NOT EXECUTED
a0010b18:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0010b1c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0010b20:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0006f5c <init_etc_passwd_group>: /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) {
a0006f5c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
a0006f60:	e59f30b8 	ldr	r3, [pc, #184]	; a0007020 <init_etc_passwd_group+0xc4><== NOT EXECUTED
a0006f64:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
a0006f68:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0006f6c:	0a000000 	beq	a0006f74 <init_etc_passwd_group+0x18>         <== NOT EXECUTED
a0006f70:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    return;                                                           
  etc_passwd_initted = 1;                                             
  mkdir("/etc", 0777);                                                
a0006f74:	e3a01f7f 	mov	r1, #508	; 0x1fc                              <== NOT EXECUTED
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
    return;                                                           
  etc_passwd_initted = 1;                                             
a0006f78:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
  mkdir("/etc", 0777);                                                
a0006f7c:	e2811003 	add	r1, r1, #3                                    <== NOT EXECUTED
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
    return;                                                           
  etc_passwd_initted = 1;                                             
a0006f80:	e5c35000 	strb	r5, [r3]                                     <== NOT EXECUTED
  mkdir("/etc", 0777);                                                
a0006f84:	e59f0098 	ldr	r0, [pc, #152]	; a0007024 <init_etc_passwd_group+0xc8><== NOT EXECUTED
a0006f88:	eb00024b 	bl	a00078bc <mkdir>                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
a0006f8c:	e59f0094 	ldr	r0, [pc, #148]	; a0007028 <init_etc_passwd_group+0xcc><== NOT EXECUTED
a0006f90:	e59f1094 	ldr	r1, [pc, #148]	; a000702c <init_etc_passwd_group+0xd0><== NOT EXECUTED
a0006f94:	eb002e82 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0006f98:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006f9c:	0a000007 	beq	a0006fc0 <init_etc_passwd_group+0x64>         <== NOT EXECUTED
  }                                                                   
  else if ((fp = fopen("/etc/passwd", "w")) != NULL) {                
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
a0006fa0:	eb002ca8 	bl	a0012248 <fclose>                              <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
a0006fa4:	e59f0084 	ldr	r0, [pc, #132]	; a0007030 <init_etc_passwd_group+0xd4><== NOT EXECUTED
a0006fa8:	e59f107c 	ldr	r1, [pc, #124]	; a000702c <init_etc_passwd_group+0xd0><== NOT EXECUTED
a0006fac:	eb002e7c 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0006fb0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006fb4:	0a00000d 	beq	a0006ff0 <init_etc_passwd_group+0x94>         <== NOT EXECUTED
    fprintf( fp, "root:x:0:root\n"                                    
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
  }                                                                   
}                                                                     
a0006fb8:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
  }                                                                   
  else if ((fp = fopen("/etc/group", "w")) != NULL) {                 
    fprintf( fp, "root:x:0:root\n"                                    
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
a0006fbc:	ea002ca1 	b	a0012248 <fclose>                               <== NOT EXECUTED
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/passwd", "w")) != NULL) {                
a0006fc0:	e59f0060 	ldr	r0, [pc, #96]	; a0007028 <init_etc_passwd_group+0xcc><== NOT EXECUTED
a0006fc4:	e59f1068 	ldr	r1, [pc, #104]	; a0007034 <init_etc_passwd_group+0xd8><== NOT EXECUTED
a0006fc8:	eb002e75 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0006fcc:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0006fd0:	0afffff3 	beq	a0006fa4 <init_etc_passwd_group+0x48>         <== NOT EXECUTED
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
a0006fd4:	e59f005c 	ldr	r0, [pc, #92]	; a0007038 <init_etc_passwd_group+0xdc><== NOT EXECUTED
a0006fd8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0006fdc:	e3a02066 	mov	r2, #102	; 0x66                               <== NOT EXECUTED
a0006fe0:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006fe4:	eb003076 	bl	a00131c4 <fwrite>                              <== NOT EXECUTED
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
a0006fe8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006fec:	eaffffeb 	b	a0006fa0 <init_etc_passwd_group+0x44>           <== NOT EXECUTED
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/group", "w")) != NULL) {                 
a0006ff0:	e59f0038 	ldr	r0, [pc, #56]	; a0007030 <init_etc_passwd_group+0xd4><== NOT EXECUTED
a0006ff4:	e59f1038 	ldr	r1, [pc, #56]	; a0007034 <init_etc_passwd_group+0xd8><== NOT EXECUTED
a0006ff8:	eb002e69 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0006ffc:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0007000:	0affffda 	beq	a0006f70 <init_etc_passwd_group+0x14>         <== NOT EXECUTED
    fprintf( fp, "root:x:0:root\n"                                    
a0007004:	e59f0030 	ldr	r0, [pc, #48]	; a000703c <init_etc_passwd_group+0xe0><== NOT EXECUTED
a0007008:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000700c:	e3a0202a 	mov	r2, #42	; 0x2a                                <== NOT EXECUTED
a0007010:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0007014:	eb00306a 	bl	a00131c4 <fwrite>                              <== NOT EXECUTED
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
a0007018:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000701c:	eaffffe5 	b	a0006fb8 <init_etc_passwd_group+0x5c>           <== NOT EXECUTED
                                                                      

a00099bc <ioctl>: int ioctl( int fd, ioctl_command_t command, ... ) {
a00099bc:	e92d000e 	push	{r1, r2, r3}                                 <== NOT EXECUTED
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
a00099c0:	e59f306c 	ldr	r3, [pc, #108]	; a0009a34 <ioctl+0x78>        <== NOT EXECUTED
int ioctl(                                                            
  int  fd,                                                            
  ioctl_command_t  command,                                           
  ...                                                                 
)                                                                     
{                                                                     
a00099c4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
a00099c8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int ioctl(                                                            
  int  fd,                                                            
  ioctl_command_t  command,                                           
  ...                                                                 
)                                                                     
{                                                                     
a00099cc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  va_list            ap;                                              
  rtems_status_code  rc;                                              
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
a00099d0:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00099d4:	2a000011 	bcs	a0009a20 <ioctl+0x64>                         <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a00099d8:	e59f3058 	ldr	r3, [pc, #88]	; a0009a38 <ioctl+0x7c>         <== NOT EXECUTED
a00099dc:	e3a02038 	mov	r2, #56	; 0x38                                <== NOT EXECUTED
a00099e0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00099e4:	e0203092 	mla	r0, r2, r0, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a00099e8:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a00099ec:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a00099f0:	0a00000a 	beq	a0009a20 <ioctl+0x64>                         <== NOT EXECUTED
  buffer = va_arg(ap, void *);                                        
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
  rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );    
a00099f4:	e5903020 	ldr	r3, [r0, #32]                                 <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
                                                                      
  va_start(ap, command);                                              
                                                                      
  buffer = va_arg(ap, void *);                                        
a00099f8:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
a00099fc:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the ioctl().                                        
   */                                                                 
  rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );    
a0009a00:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a0009a04:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
a0009a08:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
a0009a0c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  va_end( ap );                                                       
  return rc;                                                          
}                                                                     
a0009a10:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0009a14:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
a0009a18:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a0009a1c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  rtems_libio_t     *iop;                                             
  void              *buffer;                                          
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a0009a20:	eb002e2b 	bl	a00152d4 <__errno>                             <== NOT EXECUTED
a0009a24:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0009a28:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0009a2c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0009a30:	eafffff6 	b	a0009a10 <ioctl+0x54>                           <== NOT EXECUTED
                                                                      

a0008314 <iproc>: * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { if (tty->termios.c_iflag & ISTRIP)
a0008314:	e5913030 	ldr	r3, [r1, #48]	; 0x30                          <== NOT EXECUTED
/*                                                                    
 * Process a single input character                                   
 */                                                                   
static int                                                            
iproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
a0008318:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if (tty->termios.c_iflag & ISTRIP)                                  
a000831c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
/*                                                                    
 * Process a single input character                                   
 */                                                                   
static int                                                            
iproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
a0008320:	e20040ff 	and	r4, r0, #255	; 0xff                           <== NOT EXECUTED
  if (tty->termios.c_iflag & ISTRIP)                                  
    c &= 0x7f;                                                        
a0008324:	1200407f 	andne	r4, r0, #127	; 0x7f                         <== NOT EXECUTED
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
a0008328:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
/*                                                                    
 * Process a single input character                                   
 */                                                                   
static int                                                            
iproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
a000832c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  if (tty->termios.c_iflag & ISTRIP)                                  
    c &= 0x7f;                                                        
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
a0008330:	0a000007 	beq	a0008354 <iproc+0x40>                         <== NOT EXECUTED
    c = tolower (c);                                                  
a0008334:	e59f21ac 	ldr	r2, [pc, #428]	; a00084e8 <iproc+0x1d4>       <== NOT EXECUTED
a0008338:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
a000833c:	e0822004 	add	r2, r2, r4                                    <== NOT EXECUTED
a0008340:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
a0008344:	e2022003 	and	r2, r2, #3                                    <== NOT EXECUTED
a0008348:	e3520001 	cmp	r2, #1                                        <== NOT EXECUTED
a000834c:	02844020 	addeq	r4, r4, #32                                 <== NOT EXECUTED
a0008350:	e20440ff 	and	r4, r4, #255	; 0xff                           <== NOT EXECUTED
                                                                      
  if (c == '\r') {                                                    
a0008354:	e354000d 	cmp	r4, #13                                       <== NOT EXECUTED
a0008358:	0a000014 	beq	a00083b0 <iproc+0x9c>                         <== NOT EXECUTED
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
      c = '\n';                                                       
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
a000835c:	e354000a 	cmp	r4, #10                                       <== NOT EXECUTED
a0008360:	0a000034 	beq	a0008438 <iproc+0x124>                        <== NOT EXECUTED
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
a0008364:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0008368:	1a000015 	bne	a00083c4 <iproc+0xb0>                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
a000836c:	e59f2178 	ldr	r2, [pc, #376]	; a00084ec <iproc+0x1d8>       <== NOT EXECUTED
a0008370:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0008374:	e5922008 	ldr	r2, [r2, #8]                                  <== NOT EXECUTED
a0008378:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a000837c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0008380:	aa000008 	bge	a00083a8 <iproc+0x94>                         <== NOT EXECUTED
    if (tty->termios.c_lflag & ECHO)                                  
a0008384:	e595203c 	ldr	r2, [r5, #60]	; 0x3c                          <== NOT EXECUTED
a0008388:	e3120008 	tst	r2, #8                                        <== NOT EXECUTED
a000838c:	1a00002e 	bne	a000844c <iproc+0x138>                        <== NOT EXECUTED
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
a0008390:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
a0008394:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
a0008398:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
a000839c:	e7c14003 	strb	r4, [r1, r3]                                 <== NOT EXECUTED
a00083a0:	e5852020 	str	r2, [r5, #32]                                 <== NOT EXECUTED
a00083a4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
a00083a8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00083ac:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
    c = tolower (c);                                                  
                                                                      
  if (c == '\r') {                                                    
    if (tty->termios.c_iflag & IGNCR)                                 
a00083b0:	e3130080 	tst	r3, #128	; 0x80                               <== NOT EXECUTED
a00083b4:	1a000022 	bne	a0008444 <iproc+0x130>                        <== NOT EXECUTED
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
      c = '\n';                                                       
a00083b8:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a00083bc:	03a0400d 	moveq	r4, #13                                     <== NOT EXECUTED
a00083c0:	13a0400a 	movne	r4, #10                                     <== NOT EXECUTED
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
a00083c4:	e595303c 	ldr	r3, [r5, #60]	; 0x3c                          <== NOT EXECUTED
a00083c8:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a00083cc:	0affffe6 	beq	a000836c <iproc+0x58>                         <== NOT EXECUTED
    if (c == tty->termios.c_cc[VERASE]) {                             
a00083d0:	e5d52043 	ldrb	r2, [r5, #67]	; 0x43                         <== NOT EXECUTED
a00083d4:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a00083d8:	0a00003d 	beq	a00084d4 <iproc+0x1c0>                        <== NOT EXECUTED
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
a00083dc:	e5d52044 	ldrb	r2, [r5, #68]	; 0x44                         <== NOT EXECUTED
a00083e0:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a00083e4:	0a000026 	beq	a0008484 <iproc+0x170>                        <== NOT EXECUTED
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
a00083e8:	e5d52045 	ldrb	r2, [r5, #69]	; 0x45                         <== NOT EXECUTED
a00083ec:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a00083f0:	0a000035 	beq	a00084cc <iproc+0x1b8>                        <== NOT EXECUTED
      return 1;                                                       
    } else if (c == '\n') {                                           
a00083f4:	e354000a 	cmp	r4, #10                                       <== NOT EXECUTED
a00083f8:	0a000026 	beq	a0008498 <iproc+0x184>                        <== NOT EXECUTED
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
a00083fc:	e5d5204c 	ldrb	r2, [r5, #76]	; 0x4c                         <== NOT EXECUTED
a0008400:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a0008404:	0a000002 	beq	a0008414 <iproc+0x100>                        <== NOT EXECUTED
a0008408:	e5d52051 	ldrb	r2, [r5, #81]	; 0x51                         <== NOT EXECUTED
a000840c:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a0008410:	1affffd5 	bne	a000836c <iproc+0x58>                         <== NOT EXECUTED
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
a0008414:	e3130008 	tst	r3, #8                                        <== NOT EXECUTED
a0008418:	1a000015 	bne	a0008474 <iproc+0x160>                        <== NOT EXECUTED
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
a000841c:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0008420:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
      return 1;                                                       
a0008424:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
a0008428:	e0832000 	add	r2, r3, r0                                    <== NOT EXECUTED
a000842c:	e7c14003 	strb	r4, [r1, r3]                                 <== NOT EXECUTED
a0008430:	e5852020 	str	r2, [r5, #32]                                 <== NOT EXECUTED
      return 1;                                                       
a0008434:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
      c = '\n';                                                       
  } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {         
    c = '\r';                                                         
a0008438:	e3130040 	tst	r3, #64	; 0x40                                <== NOT EXECUTED
a000843c:	13a0400d 	movne	r4, #13                                     <== NOT EXECUTED
a0008440:	eaffffdf 	b	a00083c4 <iproc+0xb0>                           <== NOT EXECUTED
  if (tty->termios.c_iflag & IUCLC)                                   
    c = tolower (c);                                                  
                                                                      
  if (c == '\r') {                                                    
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
a0008444:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0008448:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
a000844c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008450:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0008454:	ebffff05 	bl	a0008070 <echo>                                <== NOT EXECUTED
a0008458:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
    tty->cbuf[tty->ccount++] = c;                                     
a000845c:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
a0008460:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
a0008464:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
a0008468:	e7c14003 	strb	r4, [r1, r3]                                 <== NOT EXECUTED
a000846c:	e5852020 	str	r2, [r5, #32]                                 <== NOT EXECUTED
a0008470:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
      tty->cbuf[tty->ccount++] = c;                                   
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
        echo (c, tty);                                                
a0008474:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008478:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000847c:	ebfffefb 	bl	a0008070 <echo>                                <== NOT EXECUTED
a0008480:	eaffffe5 	b	a000841c <iproc+0x108>                          <== NOT EXECUTED
    if (c == tty->termios.c_cc[VERASE]) {                             
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
a0008484:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0008488:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000848c:	ebffff1c 	bl	a0008104 <erase>                               <== NOT EXECUTED
      return 0;                                                       
a0008490:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0008494:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
      return 1;                                                       
    } else if (c == '\n') {                                           
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
a0008498:	e3130048 	tst	r3, #72	; 0x48                                <== NOT EXECUTED
a000849c:	0a000002 	beq	a00084ac <iproc+0x198>                        <== NOT EXECUTED
        echo (c, tty);                                                
a00084a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00084a4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00084a8:	ebfffef0 	bl	a0008070 <echo>                                <== NOT EXECUTED
      tty->cbuf[tty->ccount++] = c;                                   
a00084ac:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a00084b0:	e595101c 	ldr	r1, [r5, #28]                                 <== NOT EXECUTED
a00084b4:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a00084b8:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
a00084bc:	e7c10003 	strb	r0, [r1, r3]                                 <== NOT EXECUTED
      return 1;                                                       
a00084c0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
    else if (c == tty->termios.c_cc[VEOF]) {                          
      return 1;                                                       
    } else if (c == '\n') {                                           
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
a00084c4:	e5852020 	str	r2, [r5, #32]                                 <== NOT EXECUTED
      return 1;                                                       
a00084c8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
      return 1;                                                       
a00084cc:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a00084d0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
    if (c == tty->termios.c_cc[VERASE]) {                             
      erase (tty, 0);                                                 
a00084d4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00084d8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00084dc:	ebffff08 	bl	a0008104 <erase>                               <== NOT EXECUTED
      return 0;                                                       
a00084e0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00084e4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000a274 <is_fs_below_mount_point>: static bool is_fs_below_mount_point( const rtems_filesystem_mount_table_entry_t *mt_entry, void *arg ) { return arg == mt_entry->mt_point_node.mt_entry;
a000a274:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
}                                                                     
a000a278:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
a000a27c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a000a280:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
a000a284:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00068e8 <is_node_fs_root>: static bool is_node_fs_root( const rtems_filesystem_mount_table_entry_t *mt_entry, void *arg ) { return arg == mt_entry->mt_fs_root.node_access;
a00068e8:	e590001c 	ldr	r0, [r0, #28]                                 <== NOT EXECUTED
}                                                                     
a00068ec:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
a00068f0:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a00068f4:	03a00001 	moveq	r0, #1                                      <== NOT EXECUTED
a00068f8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000756c <issetugid>: #if defined(RTEMS_NEWLIB) && !defined(HAVE_ISSETUGID) int issetugid (void) { return 0; }
a000756c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007570:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0025a24 <kill>: #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { return 0; }
a0025a24:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0025a28:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00089c8 <lchown>: int lchown( const char *path, uid_t owner, gid_t group ) {
a00089c8:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a00089cc:	e1a02802 	lsl	r2, r2, #16                                   <== NOT EXECUTED
  return _chown_helper( path, owner, group, false );                  
a00089d0:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
a00089d4:	e1a02822 	lsr	r2, r2, #16                                   <== NOT EXECUTED
a00089d8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00089dc:	eafffef5 	b	a00085b8 <_chown_helper>                        <== NOT EXECUTED
                                                                      

a0016048 <libc_wrapup>: /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get()))
a0016048:	e59f305c 	ldr	r3, [pc, #92]	; a00160ac <libc_wrapup+0x64>   
                                                                      
extern void _wrapup_reent(struct _reent *);                           
extern void _reclaim_reent(struct _reent *);                          
                                                                      
void libc_wrapup(void)                                                
{                                                                     
a001604c:	e92d4030 	push	{r4, r5, lr}                                 
  /*                                                                  
   *  In case RTEMS is already down, don't do this.  It could be      
   *  dangerous.                                                      
   */                                                                 
                                                                      
  if (!_System_state_Is_up(_System_state_Get()))                      
a0016050:	e5933000 	ldr	r3, [r3]                                      
a0016054:	e3530003 	cmp	r3, #3                                        
a0016058:	0a000000 	beq	a0016060 <libc_wrapup+0x18>                   
a001605c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  /*                                                                  
   *  This was already done if the user called exit() directly .      
  _wrapup_reent(0);                                                   
   */                                                                 
                                                                      
  if (_REENT != _global_impure_ptr) {                                 
a0016060:	e59f4048 	ldr	r4, [pc, #72]	; a00160b0 <libc_wrapup+0x68>   
a0016064:	e59f2048 	ldr	r2, [pc, #72]	; a00160b4 <libc_wrapup+0x6c>   
a0016068:	e5943000 	ldr	r3, [r4]                                      
a001606c:	e5925000 	ldr	r5, [r2]                                      
a0016070:	e1530005 	cmp	r3, r5                                        
a0016074:	0a000003 	beq	a0016088 <libc_wrapup+0x40>                   
      _wrapup_reent(_global_impure_ptr);                              
a0016078:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001607c:	eb0001bb 	bl	a0016770 <_wrapup_reent>                       <== NOT EXECUTED
      /*  Don't reclaim this one, just in case we do printfs          
       *  on the way out to ROM.                                      
       */                                                             
      _reclaim_reent(&libc_global_reent);                             
#endif                                                                
      _REENT = _global_impure_ptr;                                    
a0016080:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
a0016084:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
   *                                                                  
   * Should this be changed to do *all* file streams?                 
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
a0016088:	e5930004 	ldr	r0, [r3, #4]                                  
a001608c:	ebffec61 	bl	a0011218 <fclose>                              
  fclose (stdout);                                                    
a0016090:	e5943000 	ldr	r3, [r4]                                      
a0016094:	e5930008 	ldr	r0, [r3, #8]                                  
a0016098:	ebffec5e 	bl	a0011218 <fclose>                              
  fclose (stderr);                                                    
a001609c:	e5943000 	ldr	r3, [r4]                                      
a00160a0:	e593000c 	ldr	r0, [r3, #12]                                 
}                                                                     
a00160a4:	e8bd4030 	pop	{r4, r5, lr}                                  
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
  fclose (stdout);                                                    
  fclose (stderr);                                                    
a00160a8:	eaffec5a 	b	a0011218 <fclose>                               
                                                                      

a0009b00 <link>: int link( const char *existing, const char *new ) {
a0009b00:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0009b04:	e24dd034 	sub	sp, sp, #52	; 0x34                            <== NOT EXECUTED
a0009b08:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0009b0c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Get the node we are linking to.                                  
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
a0009b10:	eb0039f7 	bl	a00182f4 <strlen>                              <== NOT EXECUTED
a0009b14:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a0009b18:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0009b1c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0009b20:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0009b24:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0009b28:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0009b2c:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0009b30:	ebfffde3 	bl	a00092c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                           0, &existing_loc, true );  
  if ( result != 0 )                                                  
a0009b34:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
     return -1;                                                       
a0009b38:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
   * Get the node we are linking to.                                  
   */                                                                 
                                                                      
  result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
                                           0, &existing_loc, true );  
  if ( result != 0 )                                                  
a0009b3c:	0a000002 	beq	a0009b4c <link+0x4c>                          <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &existing_loc );                         
  rtems_filesystem_freenode( &parent_loc );                           
                                                                      
  return result;                                                      
}                                                                     
a0009b40:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009b44:	e28dd034 	add	sp, sp, #52	; 0x34                            <== NOT EXECUTED
a0009b48:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Get the parent of the node we are creating.                      
   */                                                                 
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &parent_loc );             
a0009b4c:	e28d6004 	add	r6, sp, #4                                    <== NOT EXECUTED
a0009b50:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009b54:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0009b58:	e28d1030 	add	r1, sp, #48	; 0x30                            <== NOT EXECUTED
a0009b5c:	eb0004cf 	bl	a000aea0 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
                                                                      
  result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
a0009b60:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0009b64:	e59d0030 	ldr	r0, [sp, #48]	; 0x30                          <== NOT EXECUTED
a0009b68:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0009b6c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0009b70:	e0850000 	add	r0, r5, r0                                    <== NOT EXECUTED
a0009b74:	e28d202c 	add	r2, sp, #44	; 0x2c                            <== NOT EXECUTED
a0009b78:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  if ( result != 0 ) {                                                
a0009b7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0009b80:	1a000018 	bne	a0009be8 <link+0xe8>                          <== NOT EXECUTED
  /*                                                                  
   *  Check to see if the caller is trying to link across file system 
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( parent_loc.mt_entry != existing_loc.mt_entry ) {               
a0009b84:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
a0009b88:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
a0009b8c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0009b90:	1a00000b 	bne	a0009bc4 <link+0xc4>                          <== NOT EXECUTED
    rtems_filesystem_freenode( &existing_loc );                       
    rtems_filesystem_freenode( &parent_loc );                         
    rtems_set_errno_and_return_minus_one( EXDEV );                    
  }                                                                   
                                                                      
  result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
a0009b94:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0009b98:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0009b9c:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a0009ba0:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0009ba4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009ba8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0009bac:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &existing_loc );                         
a0009bb0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009bb4:	ebfffe7b 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
  rtems_filesystem_freenode( &parent_loc );                           
a0009bb8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0009bbc:	ebfffe79 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
a0009bc0:	eaffffde 	b	a0009b40 <link+0x40>                            <== NOT EXECUTED
   *  Check to see if the caller is trying to link across file system 
   *  boundaries.                                                     
   */                                                                 
                                                                      
  if ( parent_loc.mt_entry != existing_loc.mt_entry ) {               
    rtems_filesystem_freenode( &existing_loc );                       
a0009bc4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009bc8:	ebfffe76 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_filesystem_freenode( &parent_loc );                         
a0009bcc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0009bd0:	ebfffe74 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EXDEV );                    
a0009bd4:	eb002cc3 	bl	a0014ee8 <__errno>                             <== NOT EXECUTED
a0009bd8:	e3a03012 	mov	r3, #18                                       <== NOT EXECUTED
a0009bdc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0009be0:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0009be4:	eaffffd5 	b	a0009b40 <link+0x40>                            <== NOT EXECUTED
                                                                      
  rtems_filesystem_get_start_loc( new, &i, &parent_loc );             
                                                                      
  result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
  if ( result != 0 ) {                                                
    rtems_filesystem_freenode( &existing_loc );                       
a0009be8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009bec:	ebfffe6d 	bl	a00095a8 <rtems_filesystem_freenode>           <== NOT EXECUTED
    return -1;                                                        
a0009bf0:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0009bf4:	eaffffd1 	b	a0009b40 <link+0x40>                            <== NOT EXECUTED
                                                                      

a0015f04 <lseek>: { rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd );
a0015f04:	e59fc118 	ldr	ip, [pc, #280]	; a0016024 <lseek+0x120>       <== NOT EXECUTED
off_t lseek(                                                          
  int     fd,                                                         
  off_t   offset,                                                     
  int     whence                                                      
)                                                                     
{                                                                     
a0015f08:	e92d4870 	push	{r4, r5, r6, fp, lr}                         <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  off_t          old_offset;                                          
  off_t          status;                                              
                                                                      
  rtems_libio_check_fd( fd );                                         
a0015f0c:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0015f10:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
a0015f14:	2a00003c 	bcs	a001600c <lseek+0x108>                        <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0015f18:	e59fc108 	ldr	ip, [pc, #264]	; a0016028 <lseek+0x124>       <== NOT EXECUTED
a0015f1c:	e3a04038 	mov	r4, #56	; 0x38                                <== NOT EXECUTED
a0015f20:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0015f24:	e024c490 	mla	r4, r0, r4, ip                                <== NOT EXECUTED
  rtems_libio_check_is_open(iop);                                     
a0015f28:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a0015f2c:	e3100c01 	tst	r0, #256	; 0x100                              <== NOT EXECUTED
a0015f30:	0a000035 	beq	a001600c <lseek+0x108>                        <== NOT EXECUTED
  /*                                                                  
   *  Now process the lseek().                                        
   */                                                                 
                                                                      
  old_offset = iop->offset;                                           
  switch ( whence ) {                                                 
a0015f34:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the lseek().                                        
   */                                                                 
                                                                      
  old_offset = iop->offset;                                           
a0015f38:	e284600c 	add	r6, r4, #12                                   <== NOT EXECUTED
a0015f3c:	e8960060 	ldm	r6, {r5, r6}                                  <== NOT EXECUTED
  switch ( whence ) {                                                 
a0015f40:	0a000024 	beq	a0015fd8 <lseek+0xd4>                         <== NOT EXECUTED
a0015f44:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0015f48:	0a00000e 	beq	a0015f88 <lseek+0x84>                         <== NOT EXECUTED
a0015f4c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0015f50:	1a000025 	bne	a0015fec <lseek+0xe8>                         <== NOT EXECUTED
    case SEEK_SET:                                                    
      iop->offset = offset;                                           
a0015f54:	e584100c 	str	r1, [r4, #12]                                 <== NOT EXECUTED
a0015f58:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 
a0015f5c:	e594c020 	ldr	ip, [r4, #32]                                 <== NOT EXECUTED
a0015f60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0015f64:	e59cc014 	ldr	ip, [ip, #20]                                 <== NOT EXECUTED
a0015f68:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
  if ( status == (off_t) -1 )                                         
a0015f6c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 
a0015f70:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0015f74:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  if ( status == (off_t) -1 )                                         
a0015f78:	0a00000f 	beq	a0015fbc <lseek+0xb8>                         <== NOT EXECUTED
  /*                                                                  
   *  So if the operation failed, we have to restore iop->offset.     
   */                                                                 
                                                                      
  return status;                                                      
}                                                                     
a0015f7c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0015f80:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0015f84:	e8bd8870 	pop	{r4, r5, r6, fp, pc}                          <== NOT EXECUTED
    case SEEK_CUR:                                                    
      iop->offset += offset;                                          
      break;                                                          
                                                                      
    case SEEK_END:                                                    
      iop->offset = iop->size + offset;                               
a0015f88:	e9941800 	ldmib	r4, {fp, ip}                                <== NOT EXECUTED
a0015f8c:	e09bb001 	adds	fp, fp, r1                                   <== NOT EXECUTED
a0015f90:	e0acc002 	adc	ip, ip, r2                                    <== NOT EXECUTED
a0015f94:	e584b00c 	str	fp, [r4, #12]                                 <== NOT EXECUTED
a0015f98:	e584c010 	str	ip, [r4, #16]                                 <== NOT EXECUTED
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 
a0015f9c:	e594c020 	ldr	ip, [r4, #32]                                 <== NOT EXECUTED
a0015fa0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0015fa4:	e59cc014 	ldr	ip, [ip, #20]                                 <== NOT EXECUTED
a0015fa8:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
  if ( status == (off_t) -1 )                                         
a0015fac:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
  /*                                                                  
   *  At this time, handlers assume iop->offset has the desired       
   *  new offset.                                                     
   */                                                                 
                                                                      
  status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 
a0015fb0:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0015fb4:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  if ( status == (off_t) -1 )                                         
a0015fb8:	1affffef 	bne	a0015f7c <lseek+0x78>                         <== NOT EXECUTED
a0015fbc:	e3710001 	cmn	r1, #1                                        <== NOT EXECUTED
a0015fc0:	1affffed 	bne	a0015f7c <lseek+0x78>                         <== NOT EXECUTED
    iop->offset = old_offset;                                         
a0015fc4:	e584500c 	str	r5, [r4, #12]                                 <== NOT EXECUTED
a0015fc8:	e5846010 	str	r6, [r4, #16]                                 <== NOT EXECUTED
  /*                                                                  
   *  So if the operation failed, we have to restore iop->offset.     
   */                                                                 
                                                                      
  return status;                                                      
}                                                                     
a0015fcc:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0015fd0:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0015fd4:	e8bd8870 	pop	{r4, r5, r6, fp, pc}                          <== NOT EXECUTED
    case SEEK_SET:                                                    
      iop->offset = offset;                                           
      break;                                                          
                                                                      
    case SEEK_CUR:                                                    
      iop->offset += offset;                                          
a0015fd8:	e091b005 	adds	fp, r1, r5                                   <== NOT EXECUTED
a0015fdc:	e0a2c006 	adc	ip, r2, r6                                    <== NOT EXECUTED
a0015fe0:	e584b00c 	str	fp, [r4, #12]                                 <== NOT EXECUTED
a0015fe4:	e584c010 	str	ip, [r4, #16]                                 <== NOT EXECUTED
      break;                                                          
a0015fe8:	eaffffdb 	b	a0015f5c <lseek+0x58>                           <== NOT EXECUTED
    case SEEK_END:                                                    
      iop->offset = iop->size + offset;                               
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0015fec:	ebffec3b 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0015ff0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0015ff4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0015ff8:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a0015ffc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
  /*                                                                  
   *  So if the operation failed, we have to restore iop->offset.     
   */                                                                 
                                                                      
  return status;                                                      
}                                                                     
a0016000:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0016004:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0016008:	e8bd8870 	pop	{r4, r5, r6, fp, pc}                          <== NOT EXECUTED
  off_t          old_offset;                                          
  off_t          status;                                              
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
a001600c:	ebffec33 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0016010:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0016014:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0016018:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a001601c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a0016020:	eaffffd5 	b	a0015f7c <lseek+0x78>                           <== NOT EXECUTED
                                                                      

a00085a8 <lstat>: int _STAT_NAME( const char *path, struct stat *buf ) {
a00085a8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
a00085ac:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
int _STAT_NAME(                                                       
  const char  *path,                                                  
  struct stat *buf                                                    
)                                                                     
{                                                                     
a00085b0:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a00085b4:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
a00085b8:	0a000018 	beq	a0008620 <lstat+0x78>                         <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
a00085bc:	eb00313a 	bl	a0014aac <strlen>                              <== NOT EXECUTED
a00085c0:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a00085c4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a00085c8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00085cc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00085d0:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a00085d4:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a00085d8:	ebfffe21 	bl	a0007e64 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
a00085dc:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
    return -1;                                                        
a00085e0:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
  if ( !buf )                                                         
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
a00085e4:	1a00000a 	bne	a0008614 <lstat+0x6c>                         <== NOT EXECUTED
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
a00085e8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00085ec:	e3a02048 	mov	r2, #72	; 0x48                                <== NOT EXECUTED
a00085f0:	eb002f19 	bl	a001425c <memset>                              <== NOT EXECUTED
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
a00085f4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a00085f8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00085fc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008600:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0008604:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008608:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a000860c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008610:	ebfffe4d 	bl	a0007f4c <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return status;                                                      
}                                                                     
a0008614:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0008618:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a000861c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0008620:	eb002a59 	bl	a0012f8c <__errno>                             <== NOT EXECUTED
a0008624:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a0008628:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000862c:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0008630:	eafffff7 	b	a0008614 <lstat+0x6c>                           <== NOT EXECUTED
                                                                      

a0006710 <malloc>: size_t size ) { void *return_this; MSBUMP(malloc_calls, 1);
a0006710:	e59f30d8 	ldr	r3, [pc, #216]	; a00067f0 <malloc+0xe0>       
#include "malloc_p.h"                                                 
                                                                      
void *malloc(                                                         
  size_t  size                                                        
)                                                                     
{                                                                     
a0006714:	e92d4030 	push	{r4, r5, lr}                                 
  void        *return_this;                                           
                                                                      
  MSBUMP(malloc_calls, 1);                                            
a0006718:	e5932004 	ldr	r2, [r3, #4]                                  
#include "malloc_p.h"                                                 
                                                                      
void *malloc(                                                         
  size_t  size                                                        
)                                                                     
{                                                                     
a000671c:	e1a04000 	mov	r4, r0                                        
  void        *return_this;                                           
                                                                      
  MSBUMP(malloc_calls, 1);                                            
a0006720:	e2822001 	add	r2, r2, #1                                    
a0006724:	e5832004 	str	r2, [r3, #4]                                  
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
a0006728:	ebffffaf 	bl	a00065ec <malloc_deferred_frees_process>       
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
a000672c:	e3540000 	cmp	r4, #0                                        
    return (void *) 0;                                                
a0006730:	01a05004 	moveq	r5, r4                                      
  malloc_deferred_frees_process();                                    
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
a0006734:	0a000019 	beq	a00067a0 <malloc+0x90>                        
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a0006738:	e59f30b4 	ldr	r3, [pc, #180]	; a00067f4 <malloc+0xe4>       
a000673c:	e5933000 	ldr	r3, [r3]                                      
a0006740:	e3530003 	cmp	r3, #3                                        
a0006744:	0a000025 	beq	a00067e0 <malloc+0xd0>                        
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(                  
  Heap_Control *heap,                                                 
  uintptr_t size                                                      
)                                                                     
{                                                                     
  return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
a0006748:	e59f30a8 	ldr	r3, [pc, #168]	; a00067f8 <malloc+0xe8>       
a000674c:	e3a02000 	mov	r2, #0                                        
a0006750:	e1a01004 	mov	r1, r4                                        
a0006754:	e5930000 	ldr	r0, [r3]                                      
a0006758:	e1a03002 	mov	r3, r2                                        
a000675c:	eb001375 	bl	a000b538 <_Protected_heap_Allocate_aligned_with_boundary>
   * If this fails then return a NULL pointer.                        
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
a0006760:	e2505000 	subs	r5, r0, #0                                   
a0006764:	0a00000f 	beq	a00067a8 <malloc+0x98>                        
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
a0006768:	e59f308c 	ldr	r3, [pc, #140]	; a00067fc <malloc+0xec>       
a000676c:	e5933000 	ldr	r3, [r3]                                      
a0006770:	e3530000 	cmp	r3, #0                                        
a0006774:	0a000002 	beq	a0006784 <malloc+0x74>                        
    (*rtems_malloc_dirty_helper)( return_this, size );                
a0006778:	e1a00005 	mov	r0, r5                                        
a000677c:	e1a01004 	mov	r1, r4                                        
a0006780:	e12fff33 	blx	r3                                            
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
a0006784:	e59f3074 	ldr	r3, [pc, #116]	; a0006800 <malloc+0xf0>       
a0006788:	e5933000 	ldr	r3, [r3]                                      
a000678c:	e3530000 	cmp	r3, #0                                        
a0006790:	0a000002 	beq	a00067a0 <malloc+0x90>                        
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
a0006794:	e5933004 	ldr	r3, [r3, #4]                                  
a0006798:	e1a00005 	mov	r0, r5                                        
a000679c:	e12fff33 	blx	r3                                            
                                                                      
  return return_this;                                                 
}                                                                     
a00067a0:	e1a00005 	mov	r0, r5                                        
a00067a4:	e8bd8030 	pop	{r4, r5, pc}                                  
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
    if (rtems_malloc_sbrk_helpers)                                    
a00067a8:	e59f3054 	ldr	r3, [pc, #84]	; a0006804 <malloc+0xf4>        <== NOT EXECUTED
a00067ac:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00067b0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00067b4:	0a000005 	beq	a00067d0 <malloc+0xc0>                        <== NOT EXECUTED
      return_this = (*rtems_malloc_sbrk_helpers->extend)( size );     
a00067b8:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a00067bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00067c0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    if ( !return_this ) {                                             
a00067c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00067c8:	11a05000 	movne	r5, r0                                      <== NOT EXECUTED
a00067cc:	1affffe5 	bne	a0006768 <malloc+0x58>                        <== NOT EXECUTED
      errno = ENOMEM;                                                 
a00067d0:	eb002a42 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00067d4:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a00067d8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      return (void *) 0;                                              
a00067dc:	eaffffef 	b	a00067a0 <malloc+0x90>                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() )                                 
a00067e0:	ebffff6d 	bl	a000659c <malloc_is_system_state_OK>           <== NOT EXECUTED
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a00067e4:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a00067e8:	1affffd6 	bne	a0006748 <malloc+0x38>                        <== NOT EXECUTED
a00067ec:	eaffffeb 	b	a00067a0 <malloc+0x90>                          <== NOT EXECUTED
                                                                      

a0006610 <malloc_deferred_free>: void malloc_deferred_free( void *pointer ) {
a0006610:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
a0006614:	e59f0000 	ldr	r0, [pc, #0]	; a000661c <malloc_deferred_free+0xc><== NOT EXECUTED
a0006618:	ea000f73 	b	a000a3ec <_Chain_Append>                        <== NOT EXECUTED
                                                                      

a00065ec <malloc_deferred_frees_process>: void malloc_deferred_frees_process(void) {
a00065ec:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  rtems_chain_node  *to_be_freed;                                     
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
a00065f0:	ea000000 	b	a00065f8 <malloc_deferred_frees_process+0xc>    
    free(to_be_freed);                                                
a00065f4:	ebffff5e 	bl	a0006374 <free>                                <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
a00065f8:	e59f000c 	ldr	r0, [pc, #12]	; a000660c <malloc_deferred_frees_process+0x20>
a00065fc:	eb000f8d 	bl	a000a438 <_Chain_Get>                          
  rtems_chain_node  *to_be_freed;                                     
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
a0006600:	e3500000 	cmp	r0, #0                                        
a0006604:	1afffffa 	bne	a00065f4 <malloc_deferred_frees_process+0x8>  
    free(to_be_freed);                                                
}                                                                     
a0006608:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    
                                                                      

a000a558 <malloc_free_space>: /* * Find amount of free heap remaining */ size_t malloc_free_space( void ) {
a000a558:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Heap_Information info;                                              
                                                                      
  _Protected_heap_Get_free_information( RTEMS_Malloc_Heap, &info );   
a000a55c:	e59f3018 	ldr	r3, [pc, #24]	; a000a57c <malloc_free_space+0x24><== NOT EXECUTED
/*                                                                    
 *  Find amount of free heap remaining                                
 */                                                                   
                                                                      
size_t malloc_free_space( void )                                      
{                                                                     
a000a560:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
  Heap_Information info;                                              
                                                                      
  _Protected_heap_Get_free_information( RTEMS_Malloc_Heap, &info );   
a000a564:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000a568:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000a56c:	eb001948 	bl	a0010a94 <_Protected_heap_Get_free_information><== NOT EXECUTED
  return (size_t) info.largest;                                       
}                                                                     
a000a570:	e59d0004 	ldr	r0, [sp, #4]                                  <== NOT EXECUTED
a000a574:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a000a578:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a00068cc <malloc_get_heap_pointer>: #include <rtems.h> #include <rtems/libcsupport.h> #include "malloc_p.h" Heap_Control *malloc_get_heap_pointer( void ) {
a00068cc:	e59f3004 	ldr	r3, [pc, #4]	; a00068d8 <malloc_get_heap_pointer+0xc><== NOT EXECUTED
  return RTEMS_Malloc_Heap;                                           
}                                                                     
a00068d0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a00068d4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006658 <malloc_get_statistics>: #include "malloc_p.h" int malloc_get_statistics( rtems_malloc_statistics_t *stats ) {
a0006658:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if ( !stats )                                                       
a000665c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a0006660:	0a00000e 	beq	a00066a0 <malloc_get_statistics+0x48>         <== NOT EXECUTED
    return -1;                                                        
  _RTEMS_Lock_allocator();                                            
a0006664:	e59f503c 	ldr	r5, [pc, #60]	; a00066a8 <malloc_get_statistics+0x50><== NOT EXECUTED
a0006668:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000666c:	eb000f42 	bl	a000a37c <_API_Mutex_Lock>                     <== NOT EXECUTED
  *stats = rtems_malloc_statistics;                                   
a0006670:	e59fe034 	ldr	lr, [pc, #52]	; a00066ac <malloc_get_statistics+0x54><== NOT EXECUTED
a0006674:	e1a0c004 	mov	ip, r4                                        <== NOT EXECUTED
a0006678:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000667c:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0006680:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0006684:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0006688:	e89e0007 	ldm	lr, {r0, r1, r2}                              <== NOT EXECUTED
a000668c:	e88c0007 	stm	ip, {r0, r1, r2}                              <== NOT EXECUTED
  _RTEMS_Unlock_allocator();                                          
a0006690:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0006694:	eb000f54 	bl	a000a3ec <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return 0;                                                           
a0006698:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000669c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
int malloc_get_statistics(                                            
  rtems_malloc_statistics_t *stats                                    
)                                                                     
{                                                                     
  if ( !stats )                                                       
    return -1;                                                        
a00066a0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  _RTEMS_Lock_allocator();                                            
  *stats = rtems_malloc_statistics;                                   
  _RTEMS_Unlock_allocator();                                          
  return 0;                                                           
}                                                                     
a00066a4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000a580 <malloc_info>: int malloc_info( Heap_Information_block *the_info ) { if ( !the_info )
a000a580:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
 */                                                                   
                                                                      
int malloc_info(                                                      
  Heap_Information_block *the_info                                    
)                                                                     
{                                                                     
a000a584:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  if ( !the_info )                                                    
a000a588:	0a000004 	beq	a000a5a0 <malloc_info+0x20>                   <== NOT EXECUTED
    return -1;                                                        
                                                                      
  _Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );     
a000a58c:	e59f3014 	ldr	r3, [pc, #20]	; a000a5a8 <malloc_info+0x28>   <== NOT EXECUTED
a000a590:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000a594:	eb00194c 	bl	a0010acc <_Protected_heap_Get_information>     <== NOT EXECUTED
  return 0;                                                           
a000a598:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a59c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
int malloc_info(                                                      
  Heap_Information_block *the_info                                    
)                                                                     
{                                                                     
  if ( !the_info )                                                    
    return -1;                                                        
a000a5a0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  _Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );     
  return 0;                                                           
}                                                                     
a000a5a4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000659c <malloc_is_system_state_OK>: rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { if ( _Thread_Dispatch_disable_level > 0 )
a000659c:	e59f3024 	ldr	r3, [pc, #36]	; a00065c8 <malloc_is_system_state_OK+0x2c><== NOT EXECUTED
a00065a0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00065a4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00065a8:	1a000004 	bne	a00065c0 <malloc_is_system_state_OK+0x24>     <== NOT EXECUTED
    return false;                                                     
                                                                      
  if ( _ISR_Nest_level > 0 )                                          
a00065ac:	e59f3018 	ldr	r3, [pc, #24]	; a00065cc <malloc_is_system_state_OK+0x30><== NOT EXECUTED
                                                                      
#include "malloc_p.h"                                                 
                                                                      
rtems_chain_control RTEMS_Malloc_GC_list;                             
                                                                      
bool malloc_is_system_state_OK(void)                                  
a00065b0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a00065b4:	e2700001 	rsbs	r0, r0, #1                                   <== NOT EXECUTED
a00065b8:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
a00065bc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
{                                                                     
  if ( _Thread_Dispatch_disable_level > 0 )                           
    return false;                                                     
a00065c0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  if ( _ISR_Nest_level > 0 )                                          
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
a00065c4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a794 <malloc_report_statistics>: #ifdef RTEMS_NEWLIB #include "malloc_p.h" void malloc_report_statistics(void) { malloc_report_statistics_with_plugin( NULL, printk_plugin );
a000a794:	e59f1004 	ldr	r1, [pc, #4]	; a000a7a0 <malloc_report_statistics+0xc><== NOT EXECUTED
a000a798:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a79c:	ea000000 	b	a000a7a4 <malloc_report_statistics_with_plugin> <== NOT EXECUTED
                                                                      

a000a7a4 <malloc_report_statistics_with_plugin>: void malloc_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
a000a7a4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_malloc_statistics_t *s;                                       
  uintmax_t allocated;                                                
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
a000a7a8:	e59f40f4 	ldr	r4, [pc, #244]	; a000a8a4 <malloc_report_statistics_with_plugin+0x100><== NOT EXECUTED
      "max:%"PRIu32"k (%"PRIu32"%%)"                                  
      " lifetime:%"PRIu32"k freed:%"PRIu32"k\n",                      
    s->space_available / 1024,                                        
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
a000a7ac:	e3a07064 	mov	r7, #100	; 0x64                               <== NOT EXECUTED
                                                                      
void malloc_report_statistics_with_plugin(                            
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a000a7b0:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  rtems_malloc_statistics_t *s;                                       
  uintmax_t allocated;                                                
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
a000a7b4:	e2843024 	add	r3, r4, #36	; 0x24                            <== NOT EXECUTED
a000a7b8:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a000a7bc:	e284c01c 	add	ip, r4, #28                                   <== NOT EXECUTED
a000a7c0:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
a000a7c4:	e05bb002 	subs	fp, fp, r2                                   <== NOT EXECUTED
a000a7c8:	e0ccc003 	sbc	ip, ip, r3                                    <== NOT EXECUTED
      "max:%"PRIu32"k (%"PRIu32"%%)"                                  
      " lifetime:%"PRIu32"k freed:%"PRIu32"k\n",                      
    s->space_available / 1024,                                        
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
a000a7cc:	e083279b 	umull	r2, r3, fp, r7                              <== NOT EXECUTED
a000a7d0:	e1a0000c 	mov	r0, ip                                        <== NOT EXECUTED
a000a7d4:	e0203097 	mla	r0, r7, r0, r3                                <== NOT EXECUTED
    context,                                                          
    "Malloc statistics\n"                                             
    "  avail:%"PRIu32"k  allocated:%"PRIu32"k (%"PRId32"%%) "         
      "max:%"PRIu32"k (%"PRIu32"%%)"                                  
      " lifetime:%"PRIu32"k freed:%"PRIu32"k\n",                      
    s->space_available / 1024,                                        
a000a7d8:	e5946000 	ldr	r6, [r4]                                      <== NOT EXECUTED
                                                                      
void malloc_report_statistics_with_plugin(                            
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a000a7dc:	e24dd024 	sub	sp, sp, #36	; 0x24                            <== NOT EXECUTED
      "max:%"PRIu32"k (%"PRIu32"%%)"                                  
      " lifetime:%"PRIu32"k freed:%"PRIu32"k\n",                      
    s->space_available / 1024,                                        
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
a000a7e0:	e58d201c 	str	r2, [sp, #28]                                 <== NOT EXECUTED
a000a7e4:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
a000a7e8:	e58d0020 	str	r0, [sp, #32]                                 <== NOT EXECUTED
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
                                                                      
  (*print)(                                                           
a000a7ec:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
                                                                      
void malloc_report_statistics_with_plugin(                            
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a000a7f0:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
                                                                      
  (*print)(                                                           
a000a7f4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000a7f8:	e28d101c 	add	r1, sp, #28                                   <== NOT EXECUTED
a000a7fc:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
a000a800:	e1a0552b 	lsr	r5, fp, #10                                   <== NOT EXECUTED
a000a804:	e1855b0c 	orr	r5, r5, ip, lsl #22                           <== NOT EXECUTED
a000a808:	e1a0b52c 	lsr	fp, ip, #10                                   <== NOT EXECUTED
a000a80c:	eb005944 	bl	a0020d24 <__udivdi3>                           <== NOT EXECUTED
      " lifetime:%"PRIu32"k freed:%"PRIu32"k\n",                      
    s->space_available / 1024,                                        
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
    s->max_depth / 1024,                                              
a000a810:	e5949018 	ldr	r9, [r4, #24]                                 <== NOT EXECUTED
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
                                                                      
  (*print)(                                                           
a000a814:	e98d0003 	stmib	sp, {r0, r1}                                <== NOT EXECUTED
a000a818:	e1a03529 	lsr	r3, r9, #10                                   <== NOT EXECUTED
a000a81c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000a820:	e0000997 	mul	r0, r7, r9                                    <== NOT EXECUTED
a000a824:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a000a828:	ebfff414 	bl	a0007880 <__aeabi_uidiv>                       <== NOT EXECUTED
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
    s->max_depth / 1024,                                              
    (s->max_depth * 100) / s->space_available,                        
    (uint32_t) (s->lifetime_allocated / 1024),                        
a000a82c:	e594101c 	ldr	r1, [r4, #28]                                 <== NOT EXECUTED
    (uint32_t) (s->lifetime_freed / 1024)                             
a000a830:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
    s->max_depth / 1024,                                              
    (s->max_depth * 100) / s->space_available,                        
    (uint32_t) (s->lifetime_allocated / 1024),                        
a000a834:	e594e020 	ldr	lr, [r4, #32]                                 <== NOT EXECUTED
a000a838:	e1a0c521 	lsr	ip, r1, #10                                   <== NOT EXECUTED
    (uint32_t) (s->lifetime_freed / 1024)                             
a000a83c:	e5941028 	ldr	r1, [r4, #40]	; 0x28                          <== NOT EXECUTED
a000a840:	e1a03522 	lsr	r3, r2, #10                                   <== NOT EXECUTED
    allocated / 1024,                                                 
    /* avoid float! */                                                
    (allocated * 100) / s->space_available,                           
    s->max_depth / 1024,                                              
    (s->max_depth * 100) / s->space_available,                        
    (uint32_t) (s->lifetime_allocated / 1024),                        
a000a844:	e18ccb0e 	orr	ip, ip, lr, lsl #22                           <== NOT EXECUTED
    (uint32_t) (s->lifetime_freed / 1024)                             
a000a848:	e1833b01 	orr	r3, r3, r1, lsl #22                           <== NOT EXECUTED
                                                                      
  s = &rtems_malloc_statistics;                                       
                                                                      
  allocated  = s->lifetime_allocated - s->lifetime_freed;             
                                                                      
  (*print)(                                                           
a000a84c:	e1a02526 	lsr	r2, r6, #10                                   <== NOT EXECUTED
a000a850:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
a000a854:	e58d3018 	str	r3, [sp, #24]                                 <== NOT EXECUTED
a000a858:	e59f1048 	ldr	r1, [pc, #72]	; a000a8a8 <malloc_report_statistics_with_plugin+0x104><== NOT EXECUTED
a000a85c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a000a860:	e58dc014 	str	ip, [sp, #20]                                 <== NOT EXECUTED
a000a864:	e58db000 	str	fp, [sp]                                      <== NOT EXECUTED
a000a868:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000a86c:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
    s->max_depth / 1024,                                              
    (s->max_depth * 100) / s->space_available,                        
    (uint32_t) (s->lifetime_allocated / 1024),                        
    (uint32_t) (s->lifetime_freed / 1024)                             
  );                                                                  
  (*print)(                                                           
a000a870:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a000a874:	e594100c 	ldr	r1, [r4, #12]                                 <== NOT EXECUTED
a000a878:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a000a87c:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
a000a880:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a000a884:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
a000a888:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a000a88c:	e58d0008 	str	r0, [sp, #8]                                  <== NOT EXECUTED
a000a890:	e59f1014 	ldr	r1, [pc, #20]	; a000a8ac <malloc_report_statistics_with_plugin+0x108><== NOT EXECUTED
a000a894:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000a898:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
    s->memalign_calls,                                                
    s->free_calls,                                                    
    s->realloc_calls,                                                 
    s->calloc_calls                                                   
  );                                                                  
}                                                                     
a000a89c:	e28dd024 	add	sp, sp, #36	; 0x24                            <== NOT EXECUTED
a000a8a0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

a0006ac4 <malloc_sbrk_extend_and_allocate>: * Round to the "requested sbrk amount" so hopefully we won't have * to grow again for a while. This effectively does sbrk() calls * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount;
a0006ac4:	e59f30a0 	ldr	r3, [pc, #160]	; a0006b6c <malloc_sbrk_extend_and_allocate+0xa8><== NOT EXECUTED
}                                                                     
                                                                      
void *malloc_sbrk_extend_and_allocate(                                
  size_t size                                                         
)                                                                     
{                                                                     
a0006ac8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
   *  Round to the "requested sbrk amount" so hopefully we won't have 
   *  to grow again for a while.  This effectively does sbrk() calls  
   *  in "page" amounts.                                              
   */                                                                 
                                                                      
  sbrk_amount = RTEMS_Malloc_Sbrk_amount;                             
a0006acc:	e5934000 	ldr	r4, [r3]                                      <== NOT EXECUTED
}                                                                     
                                                                      
void *malloc_sbrk_extend_and_allocate(                                
  size_t size                                                         
)                                                                     
{                                                                     
a0006ad0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   *  in "page" amounts.                                              
   */                                                                 
                                                                      
  sbrk_amount = RTEMS_Malloc_Sbrk_amount;                             
                                                                      
  if ( sbrk_amount == 0 )                                             
a0006ad4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0006ad8:	1a000001 	bne	a0006ae4 <malloc_sbrk_extend_and_allocate+0x20><== NOT EXECUTED
    return (void *) 0;                                                
a0006adc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006ae0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);      
a0006ae4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006ae8:	e0800004 	add	r0, r0, r4                                    <== NOT EXECUTED
a0006aec:	eb003893 	bl	a0014d40 <__aeabi_uidiv>                       <== NOT EXECUTED
a0006af0:	e0040490 	mul	r4, r0, r4                                    <== NOT EXECUTED
                                                                      
  starting_address = (void *) sbrk(the_size);                         
a0006af4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006af8:	ebfff7f6 	bl	a0004ad8 <sbrk>                                <== NOT EXECUTED
  if ( starting_address == (void*) -1 )                               
a0006afc:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006b00:	0a000010 	beq	a0006b48 <malloc_sbrk_extend_and_allocate+0x84><== NOT EXECUTED
    return (void *) 0;                                                
                                                                      
  if ( !_Protected_heap_Extend(                                       
a0006b04:	e59f5064 	ldr	r5, [pc, #100]	; a0006b70 <malloc_sbrk_extend_and_allocate+0xac><== NOT EXECUTED
a0006b08:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0006b0c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0006b10:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0006b14:	eb001351 	bl	a000b860 <_Protected_heap_Extend>              <== NOT EXECUTED
a0006b18:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
a0006b1c:	0a00000b 	beq	a0006b50 <malloc_sbrk_extend_and_allocate+0x8c><== NOT EXECUTED
    sbrk(-the_size);                                                  
    errno = ENOMEM;                                                   
    return (void *) 0;                                                
  }                                                                   
                                                                      
  MSBUMP(space_available, the_size);                                  
a0006b20:	e59fc04c 	ldr	ip, [pc, #76]	; a0006b74 <malloc_sbrk_extend_and_allocate+0xb0><== NOT EXECUTED
a0006b24:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0006b28:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0006b2c:	e59c5000 	ldr	r5, [ip]                                      <== NOT EXECUTED
a0006b30:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0006b34:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
a0006b38:	e0844005 	add	r4, r4, r5                                    <== NOT EXECUTED
a0006b3c:	e58c4000 	str	r4, [ip]                                      <== NOT EXECUTED
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
  return return_this;                                                 
}                                                                     
a0006b40:	e8bd40f0 	pop	{r4, r5, r6, r7, lr}                          <== NOT EXECUTED
a0006b44:	ea001332 	b	a000b814 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
                                                                      
  the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);      
                                                                      
  starting_address = (void *) sbrk(the_size);                         
  if ( starting_address == (void*) -1 )                               
    return (void *) 0;                                                
a0006b48:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
  MSBUMP(space_available, the_size);                                  
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
  return return_this;                                                 
}                                                                     
a0006b4c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  if ( starting_address == (void*) -1 )                               
    return (void *) 0;                                                
                                                                      
  if ( !_Protected_heap_Extend(                                       
          RTEMS_Malloc_Heap, starting_address, the_size) ) {          
    sbrk(-the_size);                                                  
a0006b50:	e2640000 	rsb	r0, r4, #0                                    <== NOT EXECUTED
a0006b54:	ebfff7df 	bl	a0004ad8 <sbrk>                                <== NOT EXECUTED
    errno = ENOMEM;                                                   
a0006b58:	eb002ae0 	bl	a00116e0 <__errno>                             <== NOT EXECUTED
a0006b5c:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0006b60:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    return (void *) 0;                                                
a0006b64:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006b68:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a0006b78 <malloc_sbrk_initialize>: ) { uintptr_t old_address; uintptr_t uaddress; RTEMS_Malloc_Sbrk_amount = length;
a0006b78:	e59f3034 	ldr	r3, [pc, #52]	; a0006bb4 <malloc_sbrk_initialize+0x3c><== NOT EXECUTED
   * If the starting address is 0 then we are to attempt to           
   * get length worth of memory using sbrk. Make sure we              
   * align the address that we get back.                              
   */                                                                 
                                                                      
  if (!starting_address) {                                            
a0006b7c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
void *malloc_sbrk_initialize(                                         
  void  *starting_address,                                            
  size_t length                                                       
)                                                                     
{                                                                     
a0006b80:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  uintptr_t     old_address;                                          
  uintptr_t     uaddress;                                             
                                                                      
  RTEMS_Malloc_Sbrk_amount = length;                                  
a0006b84:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
   * If the starting address is 0 then we are to attempt to           
   * get length worth of memory using sbrk. Make sure we              
   * align the address that we get back.                              
   */                                                                 
                                                                      
  if (!starting_address) {                                            
a0006b88:	149df004 	popne	{pc}		; (ldrne pc, [sp], #4)                <== NOT EXECUTED
    uaddress = (uintptr_t)sbrk(length);                               
a0006b8c:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0006b90:	ebfff7d0 	bl	a0004ad8 <sbrk>                                <== NOT EXECUTED
                                                                      
    if (uaddress == (uintptr_t) -1) {                                 
a0006b94:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006b98:	0a000003 	beq	a0006bac <malloc_sbrk_initialize+0x34>        <== NOT EXECUTED
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
      /* DOES NOT RETURN!!! */                                        
    }                                                                 
                                                                      
    if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {                          
a0006b9c:	e3100007 	tst	r0, #7                                        <== NOT EXECUTED
      old_address = uaddress;                                         
      uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
a0006ba0:	12800008 	addne	r0, r0, #8                                  <== NOT EXECUTED
a0006ba4:	13c00007 	bicne	r0, r0, #7                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    starting_address = (void *)uaddress;                              
  }                                                                   
  return starting_address;                                            
}                                                                     
a0006ba8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  if (!starting_address) {                                            
    uaddress = (uintptr_t)sbrk(length);                               
                                                                      
    if (uaddress == (uintptr_t) -1) {                                 
      rtems_fatal_error_occurred( RTEMS_NO_MEMORY );                  
a0006bac:	e280001b 	add	r0, r0, #27                                   <== NOT EXECUTED
a0006bb0:	eb000e2d 	bl	a000a46c <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0006bb8 <malloc_set_heap_pointer>: void malloc_set_heap_pointer( Heap_Control *new_heap ) { RTEMS_Malloc_Heap = new_heap;
a0006bb8:	e59f3004 	ldr	r3, [pc, #4]	; a0006bc4 <malloc_set_heap_pointer+0xc><== NOT EXECUTED
a0006bbc:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
}                                                                     
a0006bc0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a9b4 <malloc_walk>: #include <stdlib.h> void malloc_walk(size_t source, size_t printf_enabled) { _Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
a000a9b4:	e2512000 	subs	r2, r1, #0                                   <== NOT EXECUTED
a000a9b8:	13a02001 	movne	r2, #1                                      <== NOT EXECUTED
a000a9bc:	e59f100c 	ldr	r1, [pc, #12]	; a000a9d0 <malloc_walk+0x1c>   <== NOT EXECUTED
#include "malloc_p.h"                                                 
                                                                      
#include <stdlib.h>                                                   
                                                                      
void malloc_walk(size_t source, size_t printf_enabled)                
{                                                                     
a000a9c0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  _Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
a000a9c4:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
a000a9c8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a000a9cc:	ea00186c 	b	a0010b84 <_Protected_heap_Walk>                 <== NOT EXECUTED
                                                                      

a000fa34 <memfile_alloc_block>: void *memfile_alloc_block(void) { void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
a000fa34:	e59f3024 	ldr	r3, [pc, #36]	; a000fa60 <memfile_alloc_block+0x2c><== NOT EXECUTED
 *  Allocate a block for an in-memory file.                           
 */                                                                   
int memfile_blocks_allocated = 0;                                     
                                                                      
void *memfile_alloc_block(void)                                       
{                                                                     
a000fa38:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  void *memory;                                                       
                                                                      
  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);           
a000fa3c:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a000fa40:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000fa44:	ebffd9dc 	bl	a00061bc <calloc>                              <== NOT EXECUTED
  if ( memory )                                                       
a000fa48:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    memfile_blocks_allocated++;                                       
a000fa4c:	159f3010 	ldrne	r3, [pc, #16]	; a000fa64 <memfile_alloc_block+0x30><== NOT EXECUTED
a000fa50:	15932000 	ldrne	r2, [r3]                                    <== NOT EXECUTED
a000fa54:	12822001 	addne	r2, r2, #1                                  <== NOT EXECUTED
a000fa58:	15832000 	strne	r2, [r3]                                    <== NOT EXECUTED
                                                                      
  return memory;                                                      
}                                                                     
a000fa5c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000f9fc <memfile_close>: { IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; if (iop->flags & LIBIO_FLAGS_APPEND)
a000f9fc:	e5902014 	ldr	r2, [r0, #20]                                 <== NOT EXECUTED
 *  nothing to flush or memory to free at this point.                 
 */                                                                   
int memfile_close(                                                    
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a000fa00:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a000fa04:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  if (iop->flags & LIBIO_FLAGS_APPEND)                                
a000fa08:	e3120c02 	tst	r2, #512	; 0x200                              <== NOT EXECUTED
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a000fa0c:	e5900018 	ldr	r0, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  if (iop->flags & LIBIO_FLAGS_APPEND)                                
    iop->offset = the_jnode->info.file.size;                          
a000fa10:	12802050 	addne	r2, r0, #80	; 0x50                          <== NOT EXECUTED
a000fa14:	18920006 	ldmne	r2, {r1, r2}                                <== NOT EXECUTED
a000fa18:	1583100c 	strne	r1, [r3, #12]                               <== NOT EXECUTED
a000fa1c:	15832010 	strne	r2, [r3, #16]                               <== NOT EXECUTED
                                                                      
  IMFS_check_node_remove( the_jnode );                                
a000fa20:	ebfffa04 	bl	a000e238 <IMFS_check_node_remove>              <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000fa24:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000fa28:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000fef8 <memfile_free_block>: * Free a block from an in-memory file. */ void memfile_free_block( void *memory ) {
a000fef8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  free(memory);                                                       
a000fefc:	ebffd91c 	bl	a0006374 <free>                                <== NOT EXECUTED
  memfile_blocks_allocated--;                                         
a000ff00:	e59f300c 	ldr	r3, [pc, #12]	; a000ff14 <memfile_free_block+0x1c><== NOT EXECUTED
a000ff04:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000ff08:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a000ff0c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
}                                                                     
a000ff10:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000ff18 <memfile_free_blocks_in_table>: */ void memfile_free_blocks_in_table( block_p **block_table, int entries ) {
a000ff18:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
a000ff1c:	e2517000 	subs	r7, r1, #0                                   <== NOT EXECUTED
 */                                                                   
void memfile_free_blocks_in_table(                                    
  block_p **block_table,                                              
  int       entries                                                   
)                                                                     
{                                                                     
a000ff20:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  IMFS_assert( block_table );                                         
                                                                      
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
a000ff24:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
a000ff28:	da00000b 	ble	a000ff5c <memfile_free_blocks_in_table+0x44>  <== NOT EXECUTED
a000ff2c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a000ff30:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    if ( b[i] ) {                                                     
      memfile_free_block( b[i] );                                     
      b[i] = 0;                                                       
a000ff34:	e1a08005 	mov	r8, r5                                        <== NOT EXECUTED
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
    if ( b[i] ) {                                                     
a000ff38:	e4960004 	ldr	r0, [r6], #4                                  <== NOT EXECUTED
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
a000ff3c:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    if ( b[i] ) {                                                     
a000ff40:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ff44:	0a000001 	beq	a000ff50 <memfile_free_blocks_in_table+0x38>  <== NOT EXECUTED
      memfile_free_block( b[i] );                                     
a000ff48:	ebffffea 	bl	a000fef8 <memfile_free_block>                  <== NOT EXECUTED
      b[i] = 0;                                                       
a000ff4c:	e5068004 	str	r8, [r6, #-4]                                 <== NOT EXECUTED
  /*                                                                  
   *  Now go through all the slots in the table and free the memory.  
   */                                                                 
  b = *block_table;                                                   
                                                                      
  for ( i=0 ; i<entries ; i++ ) {                                     
a000ff50:	e1570005 	cmp	r7, r5                                        <== NOT EXECUTED
a000ff54:	cafffff7 	bgt	a000ff38 <memfile_free_blocks_in_table+0x20>  <== NOT EXECUTED
a000ff58:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now that all the blocks in the block table are free, we can     
   *  free the block table itself.                                    
   */                                                                 
  memfile_free_block( *block_table );                                 
a000ff5c:	ebffffe5 	bl	a000fef8 <memfile_free_block>                  <== NOT EXECUTED
  *block_table = 0;                                                   
a000ff60:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ff64:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
}                                                                     
a000ff68:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a00104b8 <memfile_ftruncate>: */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) {
a00104b8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a00104bc:	e5904018 	ldr	r4, [r0, #24]                                 <== NOT EXECUTED
 */                                                                   
int memfile_ftruncate(                                                
  rtems_libio_t        *iop,                                          
  rtems_off64_t         length                                        
)                                                                     
{                                                                     
a00104c0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a00104c4:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
   *  POSIX 1003.1b does not specify what happens if you truncate a file
   *  and the new length is greater than the current size.  We treat this
   *  as an extend operation.                                         
   */                                                                 
                                                                      
  if ( length > the_jnode->info.file.size )                           
a00104c8:	e5940054 	ldr	r0, [r4, #84]	; 0x54                          <== NOT EXECUTED
a00104cc:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
a00104d0:	ba00000e 	blt	a0010510 <memfile_ftruncate+0x58>             <== NOT EXECUTED
a00104d4:	0a00000a 	beq	a0010504 <memfile_ftruncate+0x4c>             <== NOT EXECUTED
  /*                                                                  
   *  The in-memory files do not currently reclaim memory until the file is
   *  deleted.  So we leave the previously allocated blocks in place for
   *  future use and just set the length.                             
   */                                                                 
  the_jnode->info.file.size = length;                                 
a00104d8:	e5841050 	str	r1, [r4, #80]	; 0x50                          <== NOT EXECUTED
a00104dc:	e5842054 	str	r2, [r4, #84]	; 0x54                          <== NOT EXECUTED
  iop->size = the_jnode->info.file.size;                              
                                                                      
  IMFS_update_atime( the_jnode );                                     
a00104e0:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
   *  The in-memory files do not currently reclaim memory until the file is
   *  deleted.  So we leave the previously allocated blocks in place for
   *  future use and just set the length.                             
   */                                                                 
  the_jnode->info.file.size = length;                                 
  iop->size = the_jnode->info.file.size;                              
a00104e4:	e9830006 	stmib	r3, {r1, r2}                                <== NOT EXECUTED
                                                                      
  IMFS_update_atime( the_jnode );                                     
a00104e8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00104ec:	ebffd7d5 	bl	a0006448 <gettimeofday>                        <== NOT EXECUTED
a00104f0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
a00104f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   *  future use and just set the length.                             
   */                                                                 
  the_jnode->info.file.size = length;                                 
  iop->size = the_jnode->info.file.size;                              
                                                                      
  IMFS_update_atime( the_jnode );                                     
a00104f8:	e5843040 	str	r3, [r4, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a00104fc:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0010500:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
   *  POSIX 1003.1b does not specify what happens if you truncate a file
   *  and the new length is greater than the current size.  We treat this
   *  as an extend operation.                                         
   */                                                                 
                                                                      
  if ( length > the_jnode->info.file.size )                           
a0010504:	e5940050 	ldr	r0, [r4, #80]	; 0x50                          <== NOT EXECUTED
a0010508:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
a001050c:	2afffff1 	bcs	a00104d8 <memfile_ftruncate+0x20>             <== NOT EXECUTED
    return IMFS_memfile_extend( the_jnode, length );                  
a0010510:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010514:	ebfffef1 	bl	a00100e0 <IMFS_memfile_extend>                 <== NOT EXECUTED
a0010518:	eafffff7 	b	a00104fc <memfile_ftruncate+0x44>               <== NOT EXECUTED
                                                                      

a000fa2c <memfile_ioctl>: IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; return 0; }
a000fa2c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000fa30:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a001051c <memfile_lseek>: rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) {
a001051c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a0010520:	e5905018 	ldr	r5, [r0, #24]                                 <== NOT EXECUTED
rtems_off64_t memfile_lseek(                                          
  rtems_libio_t   *iop,                                               
  rtems_off64_t    offset,                                            
  int              whence                                             
)                                                                     
{                                                                     
a0010524:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
a0010528:	e595304c 	ldr	r3, [r5, #76]	; 0x4c                          <== NOT EXECUTED
a001052c:	e3530006 	cmp	r3, #6                                        <== NOT EXECUTED
a0010530:	0a00000d 	beq	a001056c <memfile_lseek+0x50>                 <== NOT EXECUTED
    if (iop->offset > the_jnode->info.linearfile.size)                
      iop->offset = the_jnode->info.linearfile.size;                  
  }                                                                   
  else {  /* Must be a block file (IMFS_MEMORY_FILE). */              
    if (IMFS_memfile_extend( the_jnode, iop->offset ))                
a0010534:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010538:	e284200c 	add	r2, r4, #12                                   <== NOT EXECUTED
a001053c:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
a0010540:	ebfffee6 	bl	a00100e0 <IMFS_memfile_extend>                 <== NOT EXECUTED
a0010544:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010548:	1a000018 	bne	a00105b0 <memfile_lseek+0x94>                 <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
                                                                      
    iop->size = the_jnode->info.file.size;                            
a001054c:	e2853050 	add	r3, r5, #80	; 0x50                            <== NOT EXECUTED
a0010550:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0010554:	e984000c 	stmib	r4, {r2, r3}                                <== NOT EXECUTED
a0010558:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
a001055c:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
  }                                                                   
  return iop->offset;                                                 
}                                                                     
a0010560:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0010564:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0010568:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  if (the_jnode->type == IMFS_LINEAR_FILE) {                          
    if (iop->offset > the_jnode->info.linearfile.size)                
a001056c:	e5951054 	ldr	r1, [r5, #84]	; 0x54                          <== NOT EXECUTED
a0010570:	e280300c 	add	r3, r0, #12                                   <== NOT EXECUTED
a0010574:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0010578:	e5950050 	ldr	r0, [r5, #80]	; 0x50                          <== NOT EXECUTED
a001057c:	e1530001 	cmp	r3, r1                                        <== NOT EXECUTED
a0010580:	ca000002 	bgt	a0010590 <memfile_lseek+0x74>                 <== NOT EXECUTED
a0010584:	1afffff5 	bne	a0010560 <memfile_lseek+0x44>                 <== NOT EXECUTED
a0010588:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
a001058c:	9afffff3 	bls	a0010560 <memfile_lseek+0x44>                 <== NOT EXECUTED
      iop->offset = the_jnode->info.linearfile.size;                  
a0010590:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0010594:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a0010598:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a001059c:	e584000c 	str	r0, [r4, #12]                                 <== NOT EXECUTED
a00105a0:	e5841010 	str	r1, [r4, #16]                                 <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
                                                                      
    iop->size = the_jnode->info.file.size;                            
  }                                                                   
  return iop->offset;                                                 
}                                                                     
a00105a4:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a00105a8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a00105ac:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    if (iop->offset > the_jnode->info.linearfile.size)                
      iop->offset = the_jnode->info.linearfile.size;                  
  }                                                                   
  else {  /* Must be a block file (IMFS_MEMORY_FILE). */              
    if (IMFS_memfile_extend( the_jnode, iop->offset ))                
      rtems_set_errno_and_return_minus_one( ENOSPC );                 
a00105b0:	eb0002ca 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00105b4:	e3a0301c 	mov	r3, #28                                       <== NOT EXECUTED
a00105b8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00105bc:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a00105c0:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a00105c4:	eaffffe5 	b	a0010560 <memfile_lseek+0x44>                   <== NOT EXECUTED
                                                                      

a0010404 <memfile_open>: rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) {
a0010404:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
a0010408:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
  rtems_libio_t *iop,                                                 
  const char    *pathname,                                            
  uint32_t       flag,                                                
  uint32_t       mode                                                 
)                                                                     
{                                                                     
a001040c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010410:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
a0010414:	e3130f81 	tst	r3, #516	; 0x204                              <== NOT EXECUTED
  uint32_t       mode                                                 
)                                                                     
{                                                                     
  IMFS_jnode_t  *the_jnode;                                           
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a0010418:	e5905018 	ldr	r5, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
a001041c:	0a000002 	beq	a001042c <memfile_open+0x28>                  <== NOT EXECUTED
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
a0010420:	e595204c 	ldr	r2, [r5, #76]	; 0x4c                          <== NOT EXECUTED
a0010424:	e3520006 	cmp	r2, #6                                        <== NOT EXECUTED
a0010428:	0a00000a 	beq	a0010458 <memfile_open+0x54>                  <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
    the_jnode->info.file.indirect        = 0;                         
    the_jnode->info.file.doubly_indirect = 0;                         
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
a001042c:	e5950050 	ldr	r0, [r5, #80]	; 0x50                          <== NOT EXECUTED
a0010430:	e5952054 	ldr	r2, [r5, #84]	; 0x54                          <== NOT EXECUTED
        return -1;                                                    
  }                                                                   
  if (iop->flags & LIBIO_FLAGS_APPEND)                                
a0010434:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
    iop->offset = the_jnode->info.file.size;                          
a0010438:	1584000c 	strne	r0, [r4, #12]                               <== NOT EXECUTED
a001043c:	15842010 	strne	r2, [r4, #16]                               <== NOT EXECUTED
a0010440:	15950050 	ldrne	r0, [r5, #80]	; 0x50                        <== NOT EXECUTED
a0010444:	15952054 	ldrne	r2, [r5, #84]	; 0x54                        <== NOT EXECUTED
                                                                      
  iop->size = the_jnode->info.file.size;                              
a0010448:	e9840005 	stmib	r4, {r0, r2}                                <== NOT EXECUTED
  return 0;                                                           
a001044c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010450:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0010454:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    uint32_t   count = the_jnode->info.linearfile.size;               
a0010458:	e595c050 	ldr	ip, [r5, #80]	; 0x50                          <== NOT EXECUTED
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
    the_jnode->info.file.size            = 0;                         
    the_jnode->info.file.indirect        = 0;                         
a001045c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
    the_jnode->info.file.size            = 0;                         
a0010460:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010464:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
a0010468:	e3a06005 	mov	r6, #5                                        <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
    the_jnode->info.file.indirect        = 0;                         
    the_jnode->info.file.doubly_indirect = 0;                         
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
a001046c:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))         
   && (the_jnode->type == IMFS_LINEAR_FILE)) {                        
    uint32_t   count = the_jnode->info.linearfile.size;               
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
a0010470:	e5953058 	ldr	r3, [r5, #88]	; 0x58                          <== NOT EXECUTED
                                                                      
    the_jnode->type = IMFS_MEMORY_FILE;                               
a0010474:	e585604c 	str	r6, [r5, #76]	; 0x4c                          <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
a0010478:	e5851050 	str	r1, [r5, #80]	; 0x50                          <== NOT EXECUTED
a001047c:	e5852054 	str	r2, [r5, #84]	; 0x54                          <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
a0010480:	e5850058 	str	r0, [r5, #88]	; 0x58                          <== NOT EXECUTED
    the_jnode->info.file.doubly_indirect = 0;                         
a0010484:	e585005c 	str	r0, [r5, #92]	; 0x5c                          <== NOT EXECUTED
    the_jnode->info.file.triply_indirect = 0;                         
a0010488:	e5850060 	str	r0, [r5, #96]	; 0x60                          <== NOT EXECUTED
    if ((count != 0)                                                  
a001048c:	1a000002 	bne	a001049c <memfile_open+0x98>                  <== NOT EXECUTED
a0010490:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a0010494:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0010498:	eaffffe5 	b	a0010434 <memfile_open+0x30>                    <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
a001049c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00104a0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00104a4:	ebffff5a 	bl	a0010214 <IMFS_memfile_write>                  <== NOT EXECUTED
a00104a8:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a00104ac:	0affffe7 	beq	a0010450 <memfile_open+0x4c>                  <== NOT EXECUTED
a00104b0:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a00104b4:	eaffffdc 	b	a001042c <memfile_open+0x28>                    <== NOT EXECUTED
                                                                      

a000fe80 <memfile_read>: ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) {
a000fe80:	e92d4800 	push	{fp, lr}                                     <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  return IMFS_memfile_read( the_jnode, iop->offset, buffer, count );  
a000fe84:	e280c00c 	add	ip, r0, #12                                   <== NOT EXECUTED
a000fe88:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
a000fe8c:	e590e018 	ldr	lr, [r0, #24]                                 <== NOT EXECUTED
ssize_t memfile_read(                                                 
  rtems_libio_t *iop,                                                 
  void          *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a000fe90:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000fe94:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  return IMFS_memfile_read( the_jnode, iop->offset, buffer, count );  
a000fe98:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000fe9c:	e1a0000e 	mov	r0, lr                                        <== NOT EXECUTED
a000fea0:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a000fea4:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a000fea8:	ebffff71 	bl	a000fc74 <IMFS_memfile_read>                   <== NOT EXECUTED
}                                                                     
a000feac:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000feb0:	e8bd8800 	pop	{fp, pc}                                      <== NOT EXECUTED
                                                                      

a00103c0 <memfile_write>: ssize_t memfile_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
a00103c0:	e92d4830 	push	{r4, r5, fp, lr}                             <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
  ssize_t         status;                                             
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count );
a00103c4:	e280c00c 	add	ip, r0, #12                                   <== NOT EXECUTED
a00103c8:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  IMFS_jnode_t   *the_jnode;                                          
  ssize_t         status;                                             
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
a00103cc:	e5905018 	ldr	r5, [r0, #24]                                 <== NOT EXECUTED
ssize_t memfile_write(                                                
  rtems_libio_t *iop,                                                 
  const void    *buffer,                                              
  size_t         count                                                
)                                                                     
{                                                                     
a00103d0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00103d4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00103d8:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
  ssize_t         status;                                             
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
                                                                      
  status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count );
a00103dc:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a00103e0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00103e4:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a00103e8:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a00103ec:	ebffff88 	bl	a0010214 <IMFS_memfile_write>                  <== NOT EXECUTED
  iop->size = the_jnode->info.file.size;                              
a00103f0:	e2853050 	add	r3, r5, #80	; 0x50                            <== NOT EXECUTED
a00103f4:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a00103f8:	e984000c 	stmib	r4, {r2, r3}                                <== NOT EXECUTED
                                                                      
  return status;                                                      
}                                                                     
a00103fc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0010400:	e8bd8830 	pop	{r4, r5, fp, pc}                              <== NOT EXECUTED
                                                                      

a00068e0 <mkfifo>: int mkfifo( const char *path, mode_t mode ) { return mknod( path, mode | S_IFIFO, 0LL );
a00068e0:	e3811a01 	orr	r1, r1, #4096	; 0x1000                        <== NOT EXECUTED
a00068e4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00068e8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00068ec:	eaffffff 	b	a00068f0 <mknod>                                <== NOT EXECUTED
                                                                      

a0006818 <mknod>: int mknod( const char *pathname, mode_t mode, dev_t dev ) {
a0006818:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
a000681c:	e1a04001 	mov	r4, r1                                        
  int                                 result;                         
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & S_IFMT)                                              
a0006820:	e2011a0f 	and	r1, r1, #61440	; 0xf000                       
a0006824:	e3510901 	cmp	r1, #16384	; 0x4000                           
int mknod(                                                            
  const char *pathname,                                               
  mode_t      mode,                                                   
  dev_t       dev                                                     
)                                                                     
{                                                                     
a0006828:	e24dd020 	sub	sp, sp, #32                                   
a000682c:	e1a05000 	mov	r5, r0                                        
a0006830:	e1a07002 	mov	r7, r2                                        
a0006834:	e1a08003 	mov	r8, r3                                        
  int                                 result;                         
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & S_IFMT)                                              
a0006838:	0a00000f 	beq	a000687c <mknod+0x64>                         
a000683c:	9a00000a 	bls	a000686c <mknod+0x54>                         
a0006840:	e3510a06 	cmp	r1, #24576	; 0x6000                           <== NOT EXECUTED
a0006844:	0a00000c 	beq	a000687c <mknod+0x64>                         <== NOT EXECUTED
a0006848:	e3510902 	cmp	r1, #32768	; 0x8000                           <== NOT EXECUTED
a000684c:	0a00000a 	beq	a000687c <mknod+0x64>                         <== NOT EXECUTED
    case S_IFBLK:                                                     
    case S_IFREG:                                                     
    case S_IFIFO:                                                     
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0006850:	eb002a22 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006854:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006858:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000685c:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
  result =  (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
                                                                      
  return result;                                                      
}                                                                     
a0006860:	e1a00004 	mov	r0, r4                                        
a0006864:	e28dd020 	add	sp, sp, #32                                   
a0006868:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
  int                                 result;                         
                                                                      
  /*                                                                  
   * The file type is field within the mode. Check we have a sane mode set.
   */                                                                 
  switch (mode & S_IFMT)                                              
a000686c:	e3510a01 	cmp	r1, #4096	; 0x1000                            
a0006870:	0a000001 	beq	a000687c <mknod+0x64>                         
a0006874:	e3510a02 	cmp	r1, #8192	; 0x2000                            
a0006878:	1afffff4 	bne	a0006850 <mknod+0x38>                         
      break;                                                          
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  }                                                                   
                                                                      
  rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );          
a000687c:	e28d6004 	add	r6, sp, #4                                    
a0006880:	e1a00005 	mov	r0, r5                                        
a0006884:	e1a02006 	mov	r2, r6                                        
a0006888:	e28d101c 	add	r1, sp, #28                                   
a000688c:	eb00026b 	bl	a0007240 <rtems_filesystem_get_start_loc>      
                                                                      
  result = (*temp_loc.ops->evalformake_h)(                            
a0006890:	e59d3010 	ldr	r3, [sp, #16]                                 
a0006894:	e59d001c 	ldr	r0, [sp, #28]                                 
a0006898:	e1a01006 	mov	r1, r6                                        
a000689c:	e5933004 	ldr	r3, [r3, #4]                                  
a00068a0:	e0850000 	add	r0, r5, r0                                    
a00068a4:	e28d2018 	add	r2, sp, #24                                   
a00068a8:	e12fff33 	blx	r3                                            
    &pathname[i],                                                     
    &temp_loc,                                                        
    &name_start                                                       
  );                                                                  
  if ( result != 0 )                                                  
a00068ac:	e3500000 	cmp	r0, #0                                        
    return -1;                                                        
a00068b0:	13e04000 	mvnne	r4, #0                                      
  result = (*temp_loc.ops->evalformake_h)(                            
    &pathname[i],                                                     
    &temp_loc,                                                        
    &name_start                                                       
  );                                                                  
  if ( result != 0 )                                                  
a00068b4:	1affffe9 	bne	a0006860 <mknod+0x48>                         
    return -1;                                                        
                                                                      
  result =  (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
a00068b8:	e59d3010 	ldr	r3, [sp, #16]                                 
a00068bc:	e58d6000 	str	r6, [sp]                                      
a00068c0:	e1a01004 	mov	r1, r4                                        
a00068c4:	e593c014 	ldr	ip, [r3, #20]                                 
a00068c8:	e59d0018 	ldr	r0, [sp, #24]                                 
a00068cc:	e1a02007 	mov	r2, r7                                        
a00068d0:	e1a03008 	mov	r3, r8                                        
a00068d4:	e12fff3c 	blx	ip                                            
a00068d8:	e1a04000 	mov	r4, r0                                        
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
a00068dc:	e1a00006 	mov	r0, r6                                        
a00068e0:	ebfffe9e 	bl	a0006360 <rtems_filesystem_freenode>           
                                                                      
  return result;                                                      
a00068e4:	eaffffdd 	b	a0006860 <mknod+0x48>                           
                                                                      

a0006970 <mount>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
a0006970:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
                                                                      
  /*                                                                  
   *  Are the file system options valid?                              
   */                                                                 
                                                                      
  if ( options != RTEMS_FILESYSTEM_READ_ONLY &&                       
a0006974:	e3530001 	cmp	r3, #1                                        
  const char                 *target,                                 
  const char                 *filesystemtype,                         
  rtems_filesystem_options_t options,                                 
  const void                 *data                                    
)                                                                     
{                                                                     
a0006978:	e24dd030 	sub	sp, sp, #48	; 0x30                            
a000697c:	e58d3008 	str	r3, [sp, #8]                                  
a0006980:	e1a07000 	mov	r7, r0                                        
a0006984:	e1a06001 	mov	r6, r1                                        
a0006988:	e1a09002 	mov	r9, r2                                        
                                                                      
  /*                                                                  
   *  Are the file system options valid?                              
   */                                                                 
                                                                      
  if ( options != RTEMS_FILESYSTEM_READ_ONLY &&                       
a000698c:	8a000099 	bhi	a0006bf8 <mount+0x288>                        
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  /*                                                                  
   *  Get mount handler                                               
   */                                                                 
  mount_h = rtems_filesystem_get_mount_handler( filesystemtype );     
a0006990:	e1a00002 	mov	r0, r2                                        
a0006994:	eb001fde 	bl	a000e914 <rtems_filesystem_get_mount_handler>  
  if ( !mount_h )                                                     
a0006998:	e3500000 	cmp	r0, #0                                        
a000699c:	e58d0014 	str	r0, [sp, #20]                                 
a00069a0:	0a000094 	beq	a0006bf8 <mount+0x288>                        
{                                                                     
  rtems_filesystem_fsmount_me_t mount_h = NULL;                       
  rtems_filesystem_location_info_t      loc;                          
  rtems_filesystem_mount_table_entry_t *mt_entry = NULL;              
  rtems_filesystem_location_info_t     *loc_to_free = NULL;           
  bool has_target = target != NULL;                                   
a00069a4:	e2565000 	subs	r5, r6, #0                                   
a00069a8:	13a05001 	movne	r5, #1                                      
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
a00069ac:	e3550000 	cmp	r5, #0                                        
a00069b0:	0a000089 	beq	a0006bdc <mount+0x26c>                        
 * 	4) The mount point exists with the proper permissions to allow mounting
 *	5) The selected mount point already has a file system mounted to it
 *                                                                    
 */                                                                   
                                                                      
int mount(                                                            
a00069b4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00069b8:	eb002db2 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a00069bc:	e2803001 	add	r3, r0, #1                                    <== NOT EXECUTED
a00069c0:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
a00069c4:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a00069c8:	e58d6018 	str	r6, [sp, #24]                                 <== NOT EXECUTED
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
a00069cc:	e1a00009 	mov	r0, r9                                        
a00069d0:	eb002dac 	bl	a0012088 <strlen>                              
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
a00069d4:	e3570000 	cmp	r7, #0                                        
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
a00069d8:	e280b001 	add	fp, r0, #1                                    
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
a00069dc:	01a08007 	moveq	r8, r7                                      
a00069e0:	0a000002 	beq	a00069f0 <mount+0x80>                         
a00069e4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00069e8:	eb002da6 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a00069ec:	e2808001 	add	r8, r0, #1                                    <== NOT EXECUTED
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size;                
a00069f0:	e59d300c 	ldr	r3, [sp, #12]                                 
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
a00069f4:	e3a00001 	mov	r0, #1                                        
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size;                
a00069f8:	e2831074 	add	r1, r3, #116	; 0x74                           
a00069fc:	e081100b 	add	r1, r1, fp                                    
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
a0006a00:	e0811008 	add	r1, r1, r8                                    
a0006a04:	ebfffdec 	bl	a00061bc <calloc>                              
                                                                      
  if ( mt_entry != NULL ) {                                           
a0006a08:	e2504000 	subs	r4, r0, #0                                   
a0006a0c:	0a00006d 	beq	a0006bc8 <mount+0x258>                        
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
a0006a10:	e284a074 	add	sl, r4, #116	; 0x74                           
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
a0006a14:	e08a300b 	add	r3, sl, fp                                    
  rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 
                                                                      
  if ( mt_entry != NULL ) {                                           
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
a0006a18:	e1a01009 	mov	r1, r9                                        
a0006a1c:	e1a0200b 	mov	r2, fp                                        
a0006a20:	e1a0000a 	mov	r0, sl                                        
a0006a24:	e58d3004 	str	r3, [sp, #4]                                  
a0006a28:	eb002bda 	bl	a0011998 <memcpy>                              
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    memcpy( str, source_or_null, source_size );                       
    mt_entry->dev = str;                                              
    str += source_size;                                               
a0006a2c:	e59d3004 	ldr	r3, [sp, #4]                                  
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    memcpy( str, source_or_null, source_size );                       
a0006a30:	e1a01007 	mov	r1, r7                                        
a0006a34:	e1a02008 	mov	r2, r8                                        
a0006a38:	e1a00003 	mov	r0, r3                                        
                                                                      
  if ( mt_entry != NULL ) {                                           
    char *str = (char *) mt_entry + sizeof( *mt_entry );              
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
a0006a3c:	e584a06c 	str	sl, [r4, #108]	; 0x6c                         
    str += filesystemtype_size;                                       
                                                                      
    memcpy( str, source_or_null, source_size );                       
    mt_entry->dev = str;                                              
    str += source_size;                                               
a0006a40:	e0839008 	add	r9, r3, r8                                    
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    memcpy( str, source_or_null, source_size );                       
a0006a44:	eb002bd3 	bl	a0011998 <memcpy>                              
    mt_entry->dev = str;                                              
a0006a48:	e59d3004 	ldr	r3, [sp, #4]                                  
    str += source_size;                                               
                                                                      
    memcpy( str, target, target_size );                               
a0006a4c:	e59d1018 	ldr	r1, [sp, #24]                                 
a0006a50:	e59d200c 	ldr	r2, [sp, #12]                                 
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    memcpy( str, source_or_null, source_size );                       
    mt_entry->dev = str;                                              
a0006a54:	e5843070 	str	r3, [r4, #112]	; 0x70                         
    str += source_size;                                               
                                                                      
    memcpy( str, target, target_size );                               
a0006a58:	e1a00009 	mov	r0, r9                                        
a0006a5c:	eb002bcd 	bl	a0011998 <memcpy>                              
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
  mt_entry->options = options;                                        
  mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
a0006a60:	e59fe208 	ldr	lr, [pc, #520]	; a0006c70 <mount+0x300>       
a0006a64:	e284c038 	add	ip, r4, #56	; 0x38                            
  /*                                                                  
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
a0006a68:	e3550000 	cmp	r5, #0                                        
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
  mt_entry->options = options;                                        
  mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
a0006a6c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
a0006a70:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
a0006a74:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         
a0006a78:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
a0006a7c:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
  mt_entry->options = options;                                        
a0006a80:	e59de008 	ldr	lr, [sp, #8]                                  
    memcpy( str, source_or_null, source_size );                       
    mt_entry->dev = str;                                              
    str += source_size;                                               
                                                                      
    memcpy( str, target, target_size );                               
    mt_entry->target = str;                                           
a0006a84:	e5849068 	str	r9, [r4, #104]	; 0x68                         
    &target_length                                                    
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  mt_entry->mt_fs_root.mt_entry = mt_entry;                           
a0006a88:	e584402c 	str	r4, [r4, #44]	; 0x2c                          
  mt_entry->options = options;                                        
a0006a8c:	e584e030 	str	lr, [r4, #48]	; 0x30                          
  mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
a0006a90:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          
  /*                                                                  
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
a0006a94:	1a000023 	bne	a0006b28 <mount+0x1b8>                        
    stop = (*routine)( mt_entry, routine_arg );                       
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return stop;                                                        
}                                                                     
a0006a98:	e59f31d4 	ldr	r3, [pc, #468]	; a0006c74 <mount+0x304>       
    }                                                                 
  } else {                                                            
    /*                                                                
     * Do we already have a base file system ?                        
     */                                                               
    if ( !rtems_chain_is_empty( &mount_chain ) ) {                    
a0006a9c:	e5932000 	ldr	r2, [r3]                                      
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(         
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return &the_chain->Tail.Node;                                       
a0006aa0:	e2833004 	add	r3, r3, #4                                    
a0006aa4:	e1520003 	cmp	r2, r3                                        
)                                                                     
{                                                                     
  rtems_filesystem_fsmount_me_t mount_h = NULL;                       
  rtems_filesystem_location_info_t      loc;                          
  rtems_filesystem_mount_table_entry_t *mt_entry = NULL;              
  rtems_filesystem_location_info_t     *loc_to_free = NULL;           
a0006aa8:	01a07005 	moveq	r7, r5                                      
    }                                                                 
  } else {                                                            
    /*                                                                
     * Do we already have a base file system ?                        
     */                                                               
    if ( !rtems_chain_is_empty( &mount_chain ) ) {                    
a0006aac:	1a000056 	bne	a0006c0c <mount+0x29c>                        
     *  mt_point_node.node_access will be left to null to indicate that this
     *  is the root of the entire file system.                        
     */                                                               
  }                                                                   
                                                                      
  if ( (*mount_h)( mt_entry, data ) ) {                               
a0006ab0:	e1a00004 	mov	r0, r4                                        
a0006ab4:	e59d1054 	ldr	r1, [sp, #84]	; 0x54                          
a0006ab8:	e59d3014 	ldr	r3, [sp, #20]                                 
a0006abc:	e12fff33 	blx	r3                                            
a0006ac0:	e2506000 	subs	r6, r0, #0                                   
a0006ac4:	1a000057 	bne	a0006c28 <mount+0x2b8>                        
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a0006ac8:	e59f71a8 	ldr	r7, [pc, #424]	; a0006c78 <mount+0x308>       
a0006acc:	e1a02006 	mov	r2, r6                                        
a0006ad0:	e1a01006 	mov	r1, r6                                        
a0006ad4:	e5970000 	ldr	r0, [r7]                                      
a0006ad8:	eb000be3 	bl	a0009a6c <rtems_semaphore_obtain>              
a0006adc:	e59f0190 	ldr	r0, [pc, #400]	; a0006c74 <mount+0x304>       
a0006ae0:	e1a01004 	mov	r1, r4                                        
a0006ae4:	eb000e40 	bl	a000a3ec <_Chain_Append>                       
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a0006ae8:	e5970000 	ldr	r0, [r7]                                      
a0006aec:	eb000c27 	bl	a0009b90 <rtems_semaphore_release>             
   */                                                                 
  rtems_libio_lock();                                                 
  rtems_chain_append( &mount_chain, &mt_entry->Node );                
  rtems_libio_unlock();                                               
                                                                      
  if ( !has_target )                                                  
a0006af0:	e3550000 	cmp	r5, #0                                        
    rtems_filesystem_root = mt_entry->mt_fs_root;                     
                                                                      
  return 0;                                                           
a0006af4:	11a05006 	movne	r5, r6                                      
   */                                                                 
  rtems_libio_lock();                                                 
  rtems_chain_append( &mount_chain, &mt_entry->Node );                
  rtems_libio_unlock();                                               
                                                                      
  if ( !has_target )                                                  
a0006af8:	1a000007 	bne	a0006b1c <mount+0x1ac>                        
    rtems_filesystem_root = mt_entry->mt_fs_root;                     
a0006afc:	e59fc178 	ldr	ip, [pc, #376]	; a0006c7c <mount+0x30c>       
a0006b00:	e284401c 	add	r4, r4, #28                                   
a0006b04:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
a0006b08:	e59cc000 	ldr	ip, [ip]                                      
a0006b0c:	e5944000 	ldr	r4, [r4]                                      
a0006b10:	e28cc018 	add	ip, ip, #24                                   
a0006b14:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
a0006b18:	e58c4000 	str	r4, [ip]                                      
                                                                      
  if ( loc_to_free )                                                  
    rtems_filesystem_freenode( loc_to_free );                         
                                                                      
  return -1;                                                          
}                                                                     
a0006b1c:	e1a00005 	mov	r0, r5                                        
a0006b20:	e28dd030 	add	sp, sp, #48	; 0x30                            
a0006b24:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
   *  The mount_point should be a directory with read/write/execute   
   *  permissions in the existing tree.                               
   */                                                                 
                                                                      
  if ( has_target ) {                                                 
    if ( rtems_filesystem_evaluate_path(                              
a0006b28:	e28d701c 	add	r7, sp, #28                                   <== NOT EXECUTED
a0006b2c:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
a0006b30:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006b34:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
a0006b38:	e3a02007 	mov	r2, #7                                        <== NOT EXECUTED
a0006b3c:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a0006b40:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0006b44:	ebfffdcb 	bl	a0006278 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a0006b48:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006b4c:	0a000031 	beq	a0006c18 <mount+0x2a8>                        <== NOT EXECUTED
                                                                      
    /*                                                                
     *  Test to see if it is a directory                              
     */                                                               
                                                                      
    if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
a0006b50:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
a0006b54:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006b58:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a0006b5c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0006b60:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0006b64:	1a000039 	bne	a0006c50 <mount+0x2e0>                        <== NOT EXECUTED
                                                                      
    /*                                                                
     *  You can only mount one file system onto a single mount point. 
     */                                                               
                                                                      
    if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
a0006b68:	e59f0110 	ldr	r0, [pc, #272]	; a0006c80 <mount+0x310>       <== NOT EXECUTED
a0006b6c:	e59d101c 	ldr	r1, [sp, #28]                                 <== NOT EXECUTED
a0006b70:	ebffff61 	bl	a00068fc <rtems_filesystem_mount_iterate>      <== NOT EXECUTED
a0006b74:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006b78:	1a000038 	bne	a0006c60 <mount+0x2f0>                        <== NOT EXECUTED
     *  may have been allocated in loc should not be sent to freenode 
     *  until the system is unmounted.  It may be needed to correctly 
     *  traverse the tree.                                            
     */                                                               
                                                                      
    mt_entry->mt_point_node.node_access = loc.node_access;            
a0006b7c:	e59d201c 	ldr	r2, [sp, #28]                                 <== NOT EXECUTED
    mt_entry->mt_point_node.handlers = loc.handlers;                  
    mt_entry->mt_point_node.ops = loc.ops;                            
a0006b80:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( loc.ops->mount_h( mt_entry ) ) {                             
a0006b84:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
     *  may have been allocated in loc should not be sent to freenode 
     *  until the system is unmounted.  It may be needed to correctly 
     *  traverse the tree.                                            
     */                                                               
                                                                      
    mt_entry->mt_point_node.node_access = loc.node_access;            
a0006b88:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
    mt_entry->mt_point_node.handlers = loc.handlers;                  
a0006b8c:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
    mt_entry->mt_point_node.ops = loc.ops;                            
a0006b90:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( loc.ops->mount_h( mt_entry ) ) {                             
a0006b94:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
     *  until the system is unmounted.  It may be needed to correctly 
     *  traverse the tree.                                            
     */                                                               
                                                                      
    mt_entry->mt_point_node.node_access = loc.node_access;            
    mt_entry->mt_point_node.handlers = loc.handlers;                  
a0006b98:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
    mt_entry->mt_point_node.ops = loc.ops;                            
    mt_entry->mt_point_node.mt_entry = loc.mt_entry;                  
a0006b9c:	e59d202c 	ldr	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a0006ba0:	e5842018 	str	r2, [r4, #24]                                 <== NOT EXECUTED
    /*                                                                
     *  This link to the parent is only done when we are dealing with system
     *  below the base file system                                    
     */                                                               
                                                                      
    if ( loc.ops->mount_h( mt_entry ) ) {                             
a0006ba4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0006ba8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006bac:	0affffbf 	beq	a0006ab0 <mount+0x140>                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( mt_entry );                                                   
a0006bb0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006bb4:	ebfffdee 	bl	a0006374 <free>                                <== NOT EXECUTED
                                                                      
  if ( loc_to_free )                                                  
    rtems_filesystem_freenode( loc_to_free );                         
a0006bb8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006bbc:	ebfffde7 	bl	a0006360 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return -1;                                                          
a0006bc0:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0006bc4:	eaffffd4 	b	a0006b1c <mount+0x1ac>                          <== NOT EXECUTED
    target,                                                           
    filesystemtype,                                                   
    &target_length                                                    
  );                                                                  
  if ( !mt_entry )                                                    
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
a0006bc8:	eb002944 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006bcc:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a0006bd0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006bd4:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0006bd8:	eaffffcf 	b	a0006b1c <mount+0x1ac>                          <== NOT EXECUTED
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
a0006bdc:	e59fe0a0 	ldr	lr, [pc, #160]	; a0006c84 <mount+0x314>       
a0006be0:	e3a03002 	mov	r3, #2                                        
a0006be4:	e58d300c 	str	r3, [sp, #12]                                 
a0006be8:	e58de018 	str	lr, [sp, #24]                                 
a0006bec:	e3a0e001 	mov	lr, #1                                        
a0006bf0:	e58de010 	str	lr, [sp, #16]                                 
a0006bf4:	eaffff74 	b	a00069cc <mount+0x5c>                           
  /*                                                                  
   *  Get mount handler                                               
   */                                                                 
  mount_h = rtems_filesystem_get_mount_handler( filesystemtype );     
  if ( !mount_h )                                                     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0006bf8:	eb002938 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006bfc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006c00:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0006c04:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0006c08:	eaffffc3 	b	a0006b1c <mount+0x1ac>                          <== NOT EXECUTED
  } else {                                                            
    /*                                                                
     * Do we already have a base file system ?                        
     */                                                               
    if ( !rtems_chain_is_empty( &mount_chain ) ) {                    
      errno = EINVAL;                                                 
a0006c0c:	eb002933 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006c10:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006c14:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  return 0;                                                           
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( mt_entry );                                                   
a0006c18:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006c1c:	ebfffdd4 	bl	a0006374 <free>                                <== NOT EXECUTED
                                                                      
  if ( loc_to_free )                                                  
    rtems_filesystem_freenode( loc_to_free );                         
                                                                      
  return -1;                                                          
a0006c20:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a0006c24:	eaffffbc 	b	a0006b1c <mount+0x1ac>                          <== NOT EXECUTED
                                                                      
  if ( (*mount_h)( mt_entry, data ) ) {                               
    /*                                                                
     * Try to undo the mount operation                                
     */                                                               
    loc.ops->unmount_h( mt_entry );                                   
a0006c28:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
a0006c2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006c30:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          <== NOT EXECUTED
a0006c34:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  return 0;                                                           
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( mt_entry );                                                   
a0006c38:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006c3c:	ebfffdcc 	bl	a0006374 <free>                                <== NOT EXECUTED
                                                                      
  if ( loc_to_free )                                                  
a0006c40:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    rtems_filesystem_freenode( loc_to_free );                         
                                                                      
  return -1;                                                          
a0006c44:	03e05000 	mvneq	r5, #0                                      <== NOT EXECUTED
                                                                      
cleanup_and_bail:                                                     
                                                                      
  free( mt_entry );                                                   
                                                                      
  if ( loc_to_free )                                                  
a0006c48:	0affffb3 	beq	a0006b1c <mount+0x1ac>                        <== NOT EXECUTED
a0006c4c:	eaffffd9 	b	a0006bb8 <mount+0x248>                          <== NOT EXECUTED
    /*                                                                
     *  Test to see if it is a directory                              
     */                                                               
                                                                      
    if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
      errno = ENOTDIR;                                                
a0006c50:	eb002922 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006c54:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a0006c58:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      goto cleanup_and_bail;                                          
a0006c5c:	eaffffd3 	b	a0006bb0 <mount+0x240>                          <== NOT EXECUTED
    /*                                                                
     *  You can only mount one file system onto a single mount point. 
     */                                                               
                                                                      
    if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
      errno = EBUSY;                                                  
a0006c60:	eb00291e 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0006c64:	e3a03010 	mov	r3, #16                                       <== NOT EXECUTED
a0006c68:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      goto cleanup_and_bail;                                          
a0006c6c:	eaffffcf 	b	a0006bb0 <mount+0x240>                          <== NOT EXECUTED
                                                                      

a0006e84 <mount_and_make_target_path>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
a0006e84:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
a0006e88:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
  const char *target,                                                 
  const char *filesystemtype,                                         
  rtems_filesystem_options_t options,                                 
  const void *data                                                    
)                                                                     
{                                                                     
a0006e8c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0006e90:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
a0006e94:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
a0006e98:	e59d5018 	ldr	r5, [sp, #24]                                 <== NOT EXECUTED
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
a0006e9c:	0a00000d 	beq	a0006ed8 <mount_and_make_target_path+0x54>    <== NOT EXECUTED
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
a0006ea0:	e3a01f7f 	mov	r1, #508	; 0x1fc                              <== NOT EXECUTED
a0006ea4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006ea8:	e2811003 	add	r1, r1, #3                                    <== NOT EXECUTED
a0006eac:	eb000264 	bl	a0007844 <rtems_mkdir>                         <== NOT EXECUTED
    if (rv == 0) {                                                    
a0006eb0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006eb4:	0a000000 	beq	a0006ebc <mount_and_make_target_path+0x38>    <== NOT EXECUTED
  } else {                                                            
    errno = EINVAL;                                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
a0006eb8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
    if (rv == 0) {                                                    
      rv = mount(                                                     
a0006ebc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006ec0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006ec4:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a0006ec8:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a0006ecc:	e58d5018 	str	r5, [sp, #24]                                 <== NOT EXECUTED
  } else {                                                            
    errno = EINVAL;                                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
a0006ed0:	e8bd41f0 	pop	{r4, r5, r6, r7, r8, lr}                      <== NOT EXECUTED
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
    if (rv == 0) {                                                    
      rv = mount(                                                     
a0006ed4:	ea000026 	b	a0006f74 <mount>                                <== NOT EXECUTED
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
a0006ed8:	eb00295e 	bl	a0011458 <__errno>                             <== NOT EXECUTED
a0006edc:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0006ee0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  const char *filesystemtype,                                         
  rtems_filesystem_options_t options,                                 
  const void *data                                                    
)                                                                     
{                                                                     
  int rv = -1;                                                        
a0006ee4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006ee8:	eafffff2 	b	a0006eb8 <mount_and_make_target_path+0x34>      <== NOT EXECUTED
                                                                      

a0006ce4 <newlib_create_hook>: rtems_tcb *creating_task ) { struct _reent *ptr; if (_Thread_libc_reent == 0)
a0006ce4:	e59f31c0 	ldr	r3, [pc, #448]	; a0006eac <newlib_create_hook+0x1c8>
 */                                                                   
bool newlib_create_hook(                                              
  rtems_tcb *current_task __attribute__((unused)),                    
  rtems_tcb *creating_task                                            
)                                                                     
{                                                                     
a0006ce8:	e92d43f0 	push	{r4, r5, r6, r7, r8, r9, lr}                 
  struct _reent *ptr;                                                 
                                                                      
  if (_Thread_libc_reent == 0)                                        
a0006cec:	e5932000 	ldr	r2, [r3]                                      
    ptr = (struct _reent *) calloc(1, sizeof(struct _reent));         
  #else                                                               
    /* It is OK to allocate from the workspace because these          
     * hooks run with thread dispatching disabled.                    
     */                                                               
    ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
a0006cf0:	e3a00e42 	mov	r0, #1056	; 0x420                             
a0006cf4:	e2800004 	add	r0, r0, #4                                    
  rtems_tcb *creating_task                                            
)                                                                     
{                                                                     
  struct _reent *ptr;                                                 
                                                                      
  if (_Thread_libc_reent == 0)                                        
a0006cf8:	e3520000 	cmp	r2, #0                                        
  {                                                                   
    _REENT = _global_impure_ptr;                                      
a0006cfc:	059f21ac 	ldreq	r2, [pc, #428]	; a0006eb0 <newlib_create_hook+0x1cc>
 */                                                                   
bool newlib_create_hook(                                              
  rtems_tcb *current_task __attribute__((unused)),                    
  rtems_tcb *creating_task                                            
)                                                                     
{                                                                     
a0006d00:	e1a05001 	mov	r5, r1                                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (                    
  struct _reent **libc_reent                                          
)                                                                     
{                                                                     
  _Thread_libc_reent = libc_reent;                                    
a0006d04:	05832000 	streq	r2, [r3]                                    
  struct _reent *ptr;                                                 
                                                                      
  if (_Thread_libc_reent == 0)                                        
  {                                                                   
    _REENT = _global_impure_ptr;                                      
a0006d08:	059f31a4 	ldreq	r3, [pc, #420]	; a0006eb4 <newlib_create_hook+0x1d0>
a0006d0c:	05933000 	ldreq	r3, [r3]                                    
a0006d10:	05823000 	streq	r3, [r2]                                    
    ptr = (struct _reent *) calloc(1, sizeof(struct _reent));         
  #else                                                               
    /* It is OK to allocate from the workspace because these          
     * hooks run with thread dispatching disabled.                    
     */                                                               
    ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
a0006d14:	eb001903 	bl	a000d128 <_Workspace_Allocate>                 
  #endif                                                              
                                                                      
  if (ptr) {                                                          
a0006d18:	e2504000 	subs	r4, r0, #0                                   
a0006d1c:	0a000060 	beq	a0006ea4 <newlib_create_hook+0x1c0>           
    _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */  
a0006d20:	e2841fef 	add	r1, r4, #956	; 0x3bc                          
a0006d24:	e584100c 	str	r1, [r4, #12]                                 
a0006d28:	e59f1188 	ldr	r1, [pc, #392]	; a0006eb8 <newlib_create_hook+0x1d4>
a0006d2c:	e3a03000 	mov	r3, #0                                        
a0006d30:	e1a00004 	mov	r0, r4                                        
a0006d34:	e3e02c21 	mvn	r2, #8448	; 0x2100                            
a0006d38:	e48032ec 	str	r3, [r0], #748	; 0x2ec                        
a0006d3c:	e2422013 	sub	r2, r2, #19                                   
a0006d40:	e2848fd5 	add	r8, r4, #852	; 0x354                          
a0006d44:	e9840101 	stmib	r4, {r0, r8}                                
a0006d48:	e5843010 	str	r3, [r4, #16]                                 
a0006d4c:	e5843014 	str	r3, [r4, #20]                                 
a0006d50:	e5843018 	str	r3, [r4, #24]                                 
a0006d54:	e584301c 	str	r3, [r4, #28]                                 
a0006d58:	e5843020 	str	r3, [r4, #32]                                 
a0006d5c:	e5843024 	str	r3, [r4, #36]	; 0x24                          
a0006d60:	e5843028 	str	r3, [r4, #40]	; 0x28                          
a0006d64:	e5c4302c 	strb	r3, [r4, #44]	; 0x2c                         
a0006d68:	e5843030 	str	r3, [r4, #48]	; 0x30                          
a0006d6c:	e5841034 	str	r1, [r4, #52]	; 0x34                          
a0006d70:	e5843038 	str	r3, [r4, #56]	; 0x38                          
a0006d74:	e584303c 	str	r3, [r4, #60]	; 0x3c                          
a0006d78:	e5843040 	str	r3, [r4, #64]	; 0x40                          
a0006d7c:	e5843044 	str	r3, [r4, #68]	; 0x44                          
a0006d80:	e5843048 	str	r3, [r4, #72]	; 0x48                          
a0006d84:	e584304c 	str	r3, [r4, #76]	; 0x4c                          
a0006d88:	e5843050 	str	r3, [r4, #80]	; 0x50                          
a0006d8c:	e5843054 	str	r3, [r4, #84]	; 0x54                          
a0006d90:	e5843058 	str	r3, [r4, #88]	; 0x58                          
a0006d94:	e584305c 	str	r3, [r4, #92]	; 0x5c                          
a0006d98:	e5c43060 	strb	r3, [r4, #96]	; 0x60                         
a0006d9c:	e584307c 	str	r3, [r4, #124]	; 0x7c                         
a0006da0:	e5843080 	str	r3, [r4, #128]	; 0x80                         
a0006da4:	e5843084 	str	r3, [r4, #132]	; 0x84                         
a0006da8:	e5843088 	str	r3, [r4, #136]	; 0x88                         
a0006dac:	e584308c 	str	r3, [r4, #140]	; 0x8c                         
a0006db0:	e5843090 	str	r3, [r4, #144]	; 0x90                         
a0006db4:	e5843094 	str	r3, [r4, #148]	; 0x94                         
a0006db8:	e5843098 	str	r3, [r4, #152]	; 0x98                         
a0006dbc:	e3a07c33 	mov	r7, #13056	; 0x3300                           
a0006dc0:	e584309c 	str	r3, [r4, #156]	; 0x9c                         
a0006dc4:	e3e06b15 	mvn	r6, #21504	; 0x5400                           
a0006dc8:	e1c42bb4 	strh	r2, [r4, #180]	; 0xb4                        
a0006dcc:	e3a0ec12 	mov	lr, #4608	; 0x1200                            
a0006dd0:	e3a02005 	mov	r2, #5                                        
a0006dd4:	e3e0cd66 	mvn	ip, #6528	; 0x1980                            
a0006dd8:	e28ee034 	add	lr, lr, #52	; 0x34                            
a0006ddc:	e24cc012 	sub	ip, ip, #18                                   
a0006de0:	e1c42bb6 	strh	r2, [r4, #182]	; 0xb6                        
a0006de4:	e287700e 	add	r7, r7, #14                                   
a0006de8:	e3a0200b 	mov	r2, #11                                       
a0006dec:	e2466032 	sub	r6, r6, #50	; 0x32                            
a0006df0:	e3a08001 	mov	r8, #1                                        
a0006df4:	e3a09000 	mov	r9, #0                                        
a0006df8:	e58430a0 	str	r3, [r4, #160]	; 0xa0                         
a0006dfc:	e1c4ebb0 	strh	lr, [r4, #176]	; 0xb0                        
a0006e00:	e1c4cbb2 	strh	ip, [r4, #178]	; 0xb2                        
a0006e04:	e58430bc 	str	r3, [r4, #188]	; 0xbc                         
a0006e08:	e58430c0 	str	r3, [r4, #192]	; 0xc0                         
a0006e0c:	e58430c4 	str	r3, [r4, #196]	; 0xc4                         
a0006e10:	e58430c8 	str	r3, [r4, #200]	; 0xc8                         
a0006e14:	e58430cc 	str	r3, [r4, #204]	; 0xcc                         
a0006e18:	e58430d0 	str	r3, [r4, #208]	; 0xd0                         
a0006e1c:	e58430f8 	str	r3, [r4, #248]	; 0xf8                         
a0006e20:	e58430fc 	str	r3, [r4, #252]	; 0xfc                         
a0006e24:	e5843100 	str	r3, [r4, #256]	; 0x100                        
a0006e28:	e5843104 	str	r3, [r4, #260]	; 0x104                        
a0006e2c:	e5843108 	str	r3, [r4, #264]	; 0x108                        
a0006e30:	e584310c 	str	r3, [r4, #268]	; 0x10c                        
a0006e34:	e5843110 	str	r3, [r4, #272]	; 0x110                        
a0006e38:	e5843114 	str	r3, [r4, #276]	; 0x114                        
a0006e3c:	e5843118 	str	r3, [r4, #280]	; 0x118                        
a0006e40:	e584311c 	str	r3, [r4, #284]	; 0x11c                        
a0006e44:	e5c430d4 	strb	r3, [r4, #212]	; 0xd4                        
a0006e48:	e5c430dc 	strb	r3, [r4, #220]	; 0xdc                        
a0006e4c:	e58430f4 	str	r3, [r4, #244]	; 0xf4                         
a0006e50:	e5843148 	str	r3, [r4, #328]	; 0x148                        
a0006e54:	e584314c 	str	r3, [r4, #332]	; 0x14c                        
a0006e58:	e5843150 	str	r3, [r4, #336]	; 0x150                        
a0006e5c:	e5843154 	str	r3, [r4, #340]	; 0x154                        
a0006e60:	e58432d4 	str	r3, [r4, #724]	; 0x2d4                        
a0006e64:	e1c42bb8 	strh	r2, [r4, #184]	; 0xb8                        
a0006e68:	e1a01003 	mov	r1, r3                                        
a0006e6c:	e58480a4 	str	r8, [r4, #164]	; 0xa4                         
a0006e70:	e58490a8 	str	r9, [r4, #168]	; 0xa8                         
a0006e74:	e1c47abc 	strh	r7, [r4, #172]	; 0xac                        
a0006e78:	e1c46abe 	strh	r6, [r4, #174]	; 0xae                        
a0006e7c:	e3a02f4e 	mov	r2, #312	; 0x138                              
a0006e80:	e58431d4 	str	r3, [r4, #468]	; 0x1d4                        
a0006e84:	e58432dc 	str	r3, [r4, #732]	; 0x2dc                        
a0006e88:	e58432e0 	str	r3, [r4, #736]	; 0x2e0                        
a0006e8c:	e58432e4 	str	r3, [r4, #740]	; 0x2e4                        
a0006e90:	e58432e8 	str	r3, [r4, #744]	; 0x2e8                        
a0006e94:	eb002af6 	bl	a0011a74 <memset>                              
    creating_task->libc_reent = ptr;                                  
a0006e98:	e58540f0 	str	r4, [r5, #240]	; 0xf0                         
    return TRUE;                                                      
a0006e9c:	e3a00001 	mov	r0, #1                                        
a0006ea0:	e8bd83f0 	pop	{r4, r5, r6, r7, r8, r9, pc}                  
  }                                                                   
                                                                      
  return FALSE;                                                       
a0006ea4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a0006ea8:	e8bd83f0 	pop	{r4, r5, r6, r7, r8, r9, pc}                  <== NOT EXECUTED
                                                                      

a0006ebc <newlib_delete_hook>: /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) {
a0006ebc:	e1500001 	cmp	r0, r1                                        <== NOT EXECUTED
    ptr = _REENT;                                                     
a0006ec0:	059f3054 	ldreq	r3, [pc, #84]	; a0006f1c <newlib_delete_hook+0x60><== NOT EXECUTED
                                                                      
void newlib_delete_hook(                                              
  rtems_tcb *current_task,                                            
  rtems_tcb *deleted_task                                             
)                                                                     
{                                                                     
a0006ec4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
    ptr = _REENT;                                                     
a0006ec8:	05935000 	ldreq	r5, [r3]                                    <== NOT EXECUTED
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
a0006ecc:	159150f0 	ldrne	r5, [r1, #240]	; 0xf0                       <== NOT EXECUTED
                                                                      
void newlib_delete_hook(                                              
  rtems_tcb *current_task,                                            
  rtems_tcb *deleted_task                                             
)                                                                     
{                                                                     
a0006ed0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0006ed4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
    ptr = _REENT;                                                     
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
  }                                                                   
                                                                      
  if (ptr && ptr != _global_impure_ptr) {                             
a0006ed8:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0006edc:	0a000008 	beq	a0006f04 <newlib_delete_hook+0x48>            <== NOT EXECUTED
a0006ee0:	e59f3038 	ldr	r3, [pc, #56]	; a0006f20 <newlib_delete_hook+0x64><== NOT EXECUTED
a0006ee4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0006ee8:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
a0006eec:	0a000004 	beq	a0006f04 <newlib_delete_hook+0x48>            <== NOT EXECUTED
    _reclaim_reent(ptr);                                              
*/                                                                    
    /*                                                                
     *  Just in case there are some buffers lying around.             
     */                                                               
    _fwalk(ptr, newlib_free_buffers);                                 
a0006ef0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0006ef4:	e59f1028 	ldr	r1, [pc, #40]	; a0006f24 <newlib_delete_hook+0x68><== NOT EXECUTED
a0006ef8:	eb002a65 	bl	a0011894 <_fwalk>                              <== NOT EXECUTED
#if REENT_MALLOCED                                                    
    free(ptr);                                                        
#else                                                                 
    _Workspace_Free(ptr);                                             
a0006efc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0006f00:	eb00188e 	bl	a000d140 <_Workspace_Free>                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
a0006f04:	e1560004 	cmp	r6, r4                                        <== NOT EXECUTED
    _REENT = 0;                                                       
a0006f08:	059f200c 	ldreq	r2, [pc, #12]	; a0006f1c <newlib_delete_hook+0x60><== NOT EXECUTED
#else                                                                 
    _Workspace_Free(ptr);                                             
#endif                                                                
  }                                                                   
                                                                      
  deleted_task->libc_reent = NULL;                                    
a0006f0c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006f10:	e58430f0 	str	r3, [r4, #240]	; 0xf0                         <== NOT EXECUTED
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
    _REENT = 0;                                                       
a0006f14:	05823000 	streq	r3, [r2]                                    <== NOT EXECUTED
a0006f18:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0006c8c <newlib_free_buffers>: */ int newlib_free_buffers( FILE *fp ) {
a0006c8c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a0006c90:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  switch ( fileno(fp) ) {                                             
a0006c94:	eb002a14 	bl	a00114ec <fileno>                              <== NOT EXECUTED
a0006c98:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a0006c9c:	9a000003 	bls	a0006cb0 <newlib_free_buffers+0x24>           <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
a0006ca0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006ca4:	eb00295b 	bl	a0011218 <fclose>                              <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
a0006ca8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006cac:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
{                                                                     
  switch ( fileno(fp) ) {                                             
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
a0006cb0:	e1d430bc 	ldrh	r3, [r4, #12]                                <== NOT EXECUTED
a0006cb4:	e3130080 	tst	r3, #128	; 0x80                               <== NOT EXECUTED
a0006cb8:	0afffffa 	beq	a0006ca8 <newlib_free_buffers+0x1c>           <== NOT EXECUTED
        free( fp->_bf._base );                                        
a0006cbc:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0006cc0:	ebfffdab 	bl	a0006374 <free>                                <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
a0006cc4:	e1d420bc 	ldrh	r2, [r4, #12]                                <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
a0006cc8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006ccc:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
        free( fp->_bf._base );                                        
        fp->_flags &= ~__SMBF;                                        
a0006cd0:	e3c22080 	bic	r2, r2, #128	; 0x80                           <== NOT EXECUTED
a0006cd4:	e1c420bc 	strh	r2, [r4, #12]                                <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
a0006cd8:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
a0006cdc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006ce0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a00060c0 <null_close>: rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { return NULL_SUCCESSFUL; }
a00060c0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00060c4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00060e4 <null_control>: rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { return NULL_SUCCESSFUL; }
a00060e4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00060e8:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000605c <null_initialize>: rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) {
a000605c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver status;                                         
                                                                      
  if ( !initialized ) {                                               
a0006060:	e59f3044 	ldr	r3, [pc, #68]	; a00060ac <null_initialize+0x50><== NOT EXECUTED
rtems_device_driver null_initialize(                                  
  rtems_device_major_number major,                                    
  rtems_device_minor_number minor __attribute__((unused)),            
  void *pargp __attribute__((unused))                                 
)                                                                     
{                                                                     
a0006064:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_device_driver status;                                         
                                                                      
  if ( !initialized ) {                                               
a0006068:	e5d32000 	ldrb	r2, [r3]                                     <== NOT EXECUTED
a000606c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0006070:	0a000001 	beq	a000607c <null_initialize+0x20>               <== NOT EXECUTED
                                                                      
    NULL_major = major;                                               
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0006074:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006078:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver status;                                         
                                                                      
  if ( !initialized ) {                                               
    initialized = 1;                                                  
a000607c:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
                                                                      
    status = rtems_io_register_name(                                  
a0006080:	e59f0028 	ldr	r0, [pc, #40]	; a00060b0 <null_initialize+0x54><== NOT EXECUTED
a0006084:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver status;                                         
                                                                      
  if ( !initialized ) {                                               
    initialized = 1;                                                  
a0006088:	e5c3c000 	strb	ip, [r3]                                     <== NOT EXECUTED
                                                                      
    status = rtems_io_register_name(                                  
a000608c:	eb00005f 	bl	a0006210 <rtems_io_register_name>              <== NOT EXECUTED
      "/dev/null",                                                    
      major,                                                          
      (rtems_device_minor_number) 0                                   
    );                                                                
                                                                      
    if (status != RTEMS_SUCCESSFUL)                                   
a0006090:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006094:	1a000003 	bne	a00060a8 <null_initialize+0x4c>               <== NOT EXECUTED
      rtems_fatal_error_occurred(status);                             
                                                                      
    NULL_major = major;                                               
a0006098:	e59f3014 	ldr	r3, [pc, #20]	; a00060b4 <null_initialize+0x58><== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000609c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    );                                                                
                                                                      
    if (status != RTEMS_SUCCESSFUL)                                   
      rtems_fatal_error_occurred(status);                             
                                                                      
    NULL_major = major;                                               
a00060a0:	e5834000 	str	r4, [r3]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a00060a4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
      major,                                                          
      (rtems_device_minor_number) 0                                   
    );                                                                
                                                                      
    if (status != RTEMS_SUCCESSFUL)                                   
      rtems_fatal_error_occurred(status);                             
a00060a8:	eb0010dd 	bl	a000a424 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a00060b8 <null_open>: rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { return NULL_SUCCESSFUL; }
a00060b8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00060bc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00060c8 <null_read>: rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { return NULL_SUCCESSFUL; }
a00060c8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00060cc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00060d0 <null_write>: void *pargp ) { rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args )
a00060d0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    rw_args->bytes_moved = rw_args->count;                            
a00060d4:	15923010 	ldrne	r3, [r2, #16]                               <== NOT EXECUTED
                                                                      
  return NULL_SUCCESSFUL;                                             
}                                                                     
a00060d8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;   
                                                                      
  if ( rw_args )                                                      
    rw_args->bytes_moved = rw_args->count;                            
a00060dc:	15823018 	strne	r3, [r2, #24]                               <== NOT EXECUTED
                                                                      
  return NULL_SUCCESSFUL;                                             
}                                                                     
a00060e0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0006f90 <open>: int open( const char *pathname, int flags, ... ) {
a0006f90:	e92d000e 	push	{r1, r2, r3}                                 
a0006f94:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             
a0006f98:	e24dd01c 	sub	sp, sp, #28                                   
a0006f9c:	e59d503c 	ldr	r5, [sp, #60]	; 0x3c                          
a0006fa0:	e1a06000 	mov	r6, r0                                        
  if ( ( status & _FWRITE ) == _FWRITE )                              
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
a0006fa4:	e59da040 	ldr	sl, [sp, #64]	; 0x40                          
                                                                      
  /*                                                                  
   * Set the Evaluation flags                                         
   */                                                                 
  eval_flags = 0;                                                     
  status = flags + 1;                                                 
a0006fa8:	e2853001 	add	r3, r5, #1                                    
  if ( ( status & _FREAD ) == _FREAD )                                
    eval_flags |= RTEMS_LIBIO_PERMS_READ;                             
a0006fac:	e2139001 	ands	r9, r3, #1                                   
a0006fb0:	13a09004 	movne	r9, #4                                      
  if ( ( status & _FWRITE ) == _FWRITE )                              
a0006fb4:	e3130002 	tst	r3, #2                                        
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
a0006fb8:	e28d3044 	add	r3, sp, #68	; 0x44                            
  eval_flags = 0;                                                     
  status = flags + 1;                                                 
  if ( ( status & _FREAD ) == _FREAD )                                
    eval_flags |= RTEMS_LIBIO_PERMS_READ;                             
  if ( ( status & _FWRITE ) == _FWRITE )                              
    eval_flags |= RTEMS_LIBIO_PERMS_WRITE;                            
a0006fbc:	13899002 	orrne	r9, r9, #2                                  
                                                                      
  va_start(ap, flags);                                                
                                                                      
  mode = va_arg( ap, int );                                           
a0006fc0:	e58d3018 	str	r3, [sp, #24]                                 
   *             code does not require changes here since network file
   *             descriptors are obtained using socket(), not open(). 
   */                                                                 
                                                                      
  /* allocate a file control block */                                 
  iop = rtems_libio_allocate();                                       
a0006fc4:	eb001d70 	bl	a000e58c <rtems_libio_allocate>                
  if ( iop == 0 ) {                                                   
a0006fc8:	e2504000 	subs	r4, r0, #0                                   
a0006fcc:	0a000033 	beq	a00070a0 <open+0x110>                         
  }                                                                   
                                                                      
  /*                                                                  
   *  See if the file exists.                                         
   */                                                                 
  status = rtems_filesystem_evaluate_path(                            
a0006fd0:	e1a00006 	mov	r0, r6                                        
a0006fd4:	eb002c2b 	bl	a0012088 <strlen>                              
a0006fd8:	e28d7004 	add	r7, sp, #4                                    
a0006fdc:	e1a01000 	mov	r1, r0                                        
a0006fe0:	e3a08001 	mov	r8, #1                                        
a0006fe4:	e1a00006 	mov	r0, r6                                        
a0006fe8:	e1a02009 	mov	r2, r9                                        
a0006fec:	e1a03007 	mov	r3, r7                                        
a0006ff0:	e58d8000 	str	r8, [sp]                                      
a0006ff4:	ebfffc9f 	bl	a0006278 <rtems_filesystem_evaluate_path>      
    pathname, strlen( pathname ), eval_flags, &loc, true );           
                                                                      
  if ( status == -1 ) {                                               
a0006ff8:	e3700001 	cmn	r0, #1                                        
a0006ffc:	0a00005b 	beq	a0007170 <open+0x1e0>                         
    if ( status != 0 ) {   /* The file did not exist */               
      rc = EACCES;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
  } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {        
a0007000:	e2053c0a 	and	r3, r5, #2560	; 0xa00                         <== NOT EXECUTED
a0007004:	e3530c0a 	cmp	r3, #2560	; 0xa00                             <== NOT EXECUTED
a0007008:	0a000029 	beq	a00070b4 <open+0x124>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
a000700c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007010:	e5948014 	ldr	r8, [r4, #20]                                 <== NOT EXECUTED
a0007014:	eb001d3c 	bl	a000e50c <rtems_libio_fcntl_flags>             <== NOT EXECUTED
  iop->pathinfo   = loc;                                              
a0007018:	e284c018 	add	ip, r4, #24                                   <== NOT EXECUTED
a000701c:	e1a0e007 	mov	lr, r7                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
a0007020:	e1808008 	orr	r8, r0, r8                                    <== NOT EXECUTED
  iop->pathinfo   = loc;                                              
a0007024:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007028:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000702c:	e59e2000 	ldr	r2, [lr]                                      <== NOT EXECUTED
                                                                      
  rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
a0007030:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Fill in the file control block based on the loc structure       
   *  returned by successful path evaluation.                         
   */                                                                 
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
a0007034:	e5848014 	str	r8, [r4, #20]                                 <== NOT EXECUTED
  iop->pathinfo   = loc;                                              
a0007038:	e58c2000 	str	r2, [ip]                                      <== NOT EXECUTED
                                                                      
  rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
a000703c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007040:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a0007044:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0007048:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000704c:	e1a0300a 	mov	r3, sl                                        <== NOT EXECUTED
a0007050:	e12fff3c 	blx	ip                                            <== NOT EXECUTED
  if ( rc ) {                                                         
a0007054:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007058:	1a00003f 	bne	a000715c <open+0x1cc>                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Optionally truncate the file.                                   
   */                                                                 
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
a000705c:	e3150b01 	tst	r5, #1024	; 0x400                             <== NOT EXECUTED
a0007060:	1a00001d 	bne	a00070dc <open+0x14c>                         <== NOT EXECUTED
a0007064:	e59f5190 	ldr	r5, [pc, #400]	; a00071fc <open+0x26c>        <== NOT EXECUTED
    if ( loc_to_free )                                                
      rtems_filesystem_freenode( loc_to_free );                       
    rtems_set_errno_and_return_minus_one( rc );                       
  }                                                                   
                                                                      
  return iop - rtems_libio_iops;                                      
a0007068:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000706c:	e0634004 	rsb	r4, r3, r4                                    <== NOT EXECUTED
a0007070:	e1a041c4 	asr	r4, r4, #3                                    <== NOT EXECUTED
a0007074:	e0843184 	add	r3, r4, r4, lsl #3                            <== NOT EXECUTED
a0007078:	e0833303 	add	r3, r3, r3, lsl #6                            <== NOT EXECUTED
a000707c:	e0843183 	add	r3, r4, r3, lsl #3                            <== NOT EXECUTED
a0007080:	e0833783 	add	r3, r3, r3, lsl #15                           <== NOT EXECUTED
a0007084:	e0844183 	add	r4, r4, r3, lsl #3                            <== NOT EXECUTED
a0007088:	e2644000 	rsb	r4, r4, #0                                    <== NOT EXECUTED
}                                                                     
a000708c:	e1a00004 	mov	r0, r4                                        
a0007090:	e28dd01c 	add	sp, sp, #28                                   
a0007094:	e8bd47f0 	pop	{r4, r5, r6, r7, r8, r9, sl, lr}              
a0007098:	e28dd00c 	add	sp, sp, #12                                   
a000709c:	e12fff1e 	bx	lr                                             
   */                                                                 
                                                                      
  /* allocate a file control block */                                 
  iop = rtems_libio_allocate();                                       
  if ( iop == 0 ) {                                                   
    rc = ENFILE;                                                      
a00070a0:	e3a06017 	mov	r6, #23                                       <== NOT EXECUTED
  if ( rc ) {                                                         
    if ( iop )                                                        
      rtems_libio_free( iop );                                        
    if ( loc_to_free )                                                
      rtems_filesystem_freenode( loc_to_free );                       
    rtems_set_errno_and_return_minus_one( rc );                       
a00070a4:	eb00280d 	bl	a00110e0 <__errno>                             
a00070a8:	e3e04000 	mvn	r4, #0                                        
a00070ac:	e5806000 	str	r6, [r0]                                      
a00070b0:	eafffff5 	b	a000708c <open+0xfc>                            
      goto done;                                                      
    }                                                                 
                                                                      
  } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {        
    /* We were trying to create a file that already exists */         
    rc = EEXIST;                                                      
a00070b4:	e3a06011 	mov	r6, #17                                       <== NOT EXECUTED
   */                                                                 
done:                                                                 
  va_end(ap);                                                         
                                                                      
  if ( rc ) {                                                         
    if ( iop )                                                        
a00070b8:	e3540000 	cmp	r4, #0                                        
a00070bc:	0a000001 	beq	a00070c8 <open+0x138>                         
      rtems_libio_free( iop );                                        
a00070c0:	e1a00004 	mov	r0, r4                                        
a00070c4:	eb001d72 	bl	a000e694 <rtems_libio_free>                    
    if ( loc_to_free )                                                
a00070c8:	e3570000 	cmp	r7, #0                                        
a00070cc:	0afffff4 	beq	a00070a4 <open+0x114>                         
      rtems_filesystem_freenode( loc_to_free );                       
a00070d0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00070d4:	ebfffca1 	bl	a0006360 <rtems_filesystem_freenode>           <== NOT EXECUTED
a00070d8:	eafffff1 	b	a00070a4 <open+0x114>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optionally truncate the file.                                   
   */                                                                 
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
    rc = ftruncate( iop - rtems_libio_iops, 0 );                      
a00070dc:	e59f5118 	ldr	r5, [pc, #280]	; a00071fc <open+0x26c>        <== NOT EXECUTED
a00070e0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00070e4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00070e8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a00070ec:	e0633004 	rsb	r3, r3, r4                                    <== NOT EXECUTED
a00070f0:	e1a031c3 	asr	r3, r3, #3                                    <== NOT EXECUTED
a00070f4:	e0830183 	add	r0, r3, r3, lsl #3                            <== NOT EXECUTED
a00070f8:	e0800300 	add	r0, r0, r0, lsl #6                            <== NOT EXECUTED
a00070fc:	e0830180 	add	r0, r3, r0, lsl #3                            <== NOT EXECUTED
a0007100:	e0800780 	add	r0, r0, r0, lsl #15                           <== NOT EXECUTED
a0007104:	e0830180 	add	r0, r3, r0, lsl #3                            <== NOT EXECUTED
a0007108:	e2600000 	rsb	r0, r0, #0                                    <== NOT EXECUTED
a000710c:	eb001cc7 	bl	a000e430 <ftruncate>                           <== NOT EXECUTED
    if ( rc ) {                                                       
a0007110:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0007114:	0affffd3 	beq	a0007068 <open+0xd8>                          <== NOT EXECUTED
      if(errno) rc = errno;                                           
a0007118:	eb0027f0 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000711c:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0007120:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007124:	1a000031 	bne	a00071f0 <open+0x260>                         <== NOT EXECUTED
      close( iop - rtems_libio_iops );                                
a0007128:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000712c:	e0634004 	rsb	r4, r3, r4                                    <== NOT EXECUTED
a0007130:	e1a041c4 	asr	r4, r4, #3                                    <== NOT EXECUTED
a0007134:	e0843184 	add	r3, r4, r4, lsl #3                            <== NOT EXECUTED
a0007138:	e0833303 	add	r3, r3, r3, lsl #6                            <== NOT EXECUTED
a000713c:	e0843183 	add	r3, r4, r3, lsl #3                            <== NOT EXECUTED
a0007140:	e0833783 	add	r3, r3, r3, lsl #15                           <== NOT EXECUTED
a0007144:	e0840183 	add	r0, r4, r3, lsl #3                            <== NOT EXECUTED
a0007148:	e2600000 	rsb	r0, r0, #0                                    <== NOT EXECUTED
      /* those are released by close(): */                            
      iop = 0;                                                        
      loc_to_free = NULL;                                             
a000714c:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
   */                                                                 
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
    rc = ftruncate( iop - rtems_libio_iops, 0 );                      
    if ( rc ) {                                                       
      if(errno) rc = errno;                                           
      close( iop - rtems_libio_iops );                                
a0007150:	eb001c96 	bl	a000e3b0 <close>                               <== NOT EXECUTED
      /* those are released by close(): */                            
      iop = 0;                                                        
a0007154:	e1a07004 	mov	r7, r4                                        <== NOT EXECUTED
a0007158:	ea000001 	b	a0007164 <open+0x1d4>                           <== NOT EXECUTED
  iop->flags     |= rtems_libio_fcntl_flags( flags );                 
  iop->pathinfo   = loc;                                              
                                                                      
  rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
  if ( rc ) {                                                         
    rc = errno;                                                       
a000715c:	eb0027df 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0007160:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
   *  Single exit and clean up path.                                  
   */                                                                 
done:                                                                 
  va_end(ap);                                                         
                                                                      
  if ( rc ) {                                                         
a0007164:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0007168:	0affffbd 	beq	a0007064 <open+0xd4>                          <== NOT EXECUTED
a000716c:	eaffffd1 	b	a00070b8 <open+0x128>                           <== NOT EXECUTED
   */                                                                 
  status = rtems_filesystem_evaluate_path(                            
    pathname, strlen( pathname ), eval_flags, &loc, true );           
                                                                      
  if ( status == -1 ) {                                               
    if ( errno != ENOENT ) {                                          
a0007170:	eb0027da 	bl	a00110e0 <__errno>                             
a0007174:	e5903000 	ldr	r3, [r0]                                      
a0007178:	e3530002 	cmp	r3, #2                                        
a000717c:	0a000003 	beq	a0007190 <open+0x200>                         
    }                                                                 
                                                                      
    /* Create the node for the new regular file */                    
    rc = mknod( pathname, S_IFREG | mode, 0LL );                      
    if ( rc ) {                                                       
      rc = errno;                                                     
a0007180:	eb0027d6 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
  int                                 mode;                           
  int                                 rc;                             
  rtems_libio_t                      *iop = 0;                        
  int                                 status;                         
  rtems_filesystem_location_info_t    loc;                            
  rtems_filesystem_location_info_t   *loc_to_free = NULL;             
a0007184:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Create the node for the new regular file */                    
    rc = mknod( pathname, S_IFREG | mode, 0LL );                      
    if ( rc ) {                                                       
      rc = errno;                                                     
a0007188:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
      goto done;                                                      
a000718c:	eafffff4 	b	a0007164 <open+0x1d4>                           <== NOT EXECUTED
      rc = errno;                                                     
      goto done;                                                      
    }                                                                 
                                                                      
    /* If the file does not exist and we are not trying to create it--> error */
    if ( !(flags & O_CREAT) ) {                                       
a0007190:	e2159c02 	ands	r9, r5, #512	; 0x200                         
  int                                 mode;                           
  int                                 rc;                             
  rtems_libio_t                      *iop = 0;                        
  int                                 status;                         
  rtems_filesystem_location_info_t    loc;                            
  rtems_filesystem_location_info_t   *loc_to_free = NULL;             
a0007194:	01a07009 	moveq	r7, r9                                      
      goto done;                                                      
    }                                                                 
                                                                      
    /* If the file does not exist and we are not trying to create it--> error */
    if ( !(flags & O_CREAT) ) {                                       
      rc = ENOENT;                                                    
a0007198:	01a06003 	moveq	r6, r3                                      
      rc = errno;                                                     
      goto done;                                                      
    }                                                                 
                                                                      
    /* If the file does not exist and we are not trying to create it--> error */
    if ( !(flags & O_CREAT) ) {                                       
a000719c:	0affffc5 	beq	a00070b8 <open+0x128>                         
      rc = ENOENT;                                                    
      goto done;                                                      
    }                                                                 
                                                                      
    /* Create the node for the new regular file */                    
    rc = mknod( pathname, S_IFREG | mode, 0LL );                      
a00071a0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00071a4:	e38a1902 	orr	r1, sl, #32768	; 0x8000                       <== NOT EXECUTED
a00071a8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00071ac:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00071b0:	ebfffd98 	bl	a0006818 <mknod>                               <== NOT EXECUTED
    if ( rc ) {                                                       
a00071b4:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
a00071b8:	1afffff0 	bne	a0007180 <open+0x1f0>                         <== NOT EXECUTED
    /*                                                                
     * After we do the mknod(), we have to evaluate the path to get the
     * "loc" structure needed to actually have the file itself open.  
     * So we created it, and then we need to have "look it up."       
     */                                                               
    status = rtems_filesystem_evaluate_path(                          
a00071bc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00071c0:	eb002bb0 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a00071c4:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a00071c8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a00071cc:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
a00071d0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00071d4:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
a00071d8:	ebfffc26 	bl	a0006278 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
      pathname, strlen( pathname ), 0x0, &loc, true );                
    if ( status != 0 ) {   /* The file did not exist */               
a00071dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  int                                 mode;                           
  int                                 rc;                             
  rtems_libio_t                      *iop = 0;                        
  int                                 status;                         
  rtems_filesystem_location_info_t    loc;                            
  rtems_filesystem_location_info_t   *loc_to_free = NULL;             
a00071e0:	11a07009 	movne	r7, r9                                      <== NOT EXECUTED
     * So we created it, and then we need to have "look it up."       
     */                                                               
    status = rtems_filesystem_evaluate_path(                          
      pathname, strlen( pathname ), 0x0, &loc, true );                
    if ( status != 0 ) {   /* The file did not exist */               
      rc = EACCES;                                                    
a00071e4:	13a0600d 	movne	r6, #13                                     <== NOT EXECUTED
     * "loc" structure needed to actually have the file itself open.  
     * So we created it, and then we need to have "look it up."       
     */                                                               
    status = rtems_filesystem_evaluate_path(                          
      pathname, strlen( pathname ), 0x0, &loc, true );                
    if ( status != 0 ) {   /* The file did not exist */               
a00071e8:	1affffb2 	bne	a00070b8 <open+0x128>                         <== NOT EXECUTED
a00071ec:	eaffff86 	b	a000700c <open+0x7c>                            <== NOT EXECUTED
   *  Optionally truncate the file.                                   
   */                                                                 
  if ( (flags & O_TRUNC) == O_TRUNC ) {                               
    rc = ftruncate( iop - rtems_libio_iops, 0 );                      
    if ( rc ) {                                                       
      if(errno) rc = errno;                                           
a00071f0:	eb0027ba 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00071f4:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
a00071f8:	eaffffca 	b	a0007128 <open+0x198>                           <== NOT EXECUTED
                                                                      

a0006f28 <open_dev_console>: int stderr_fd; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
a0006f28:	e3a01000 	mov	r1, #0                                        
                                                                      
/*                                                                    
 *  This is a replaceable stub which opens the console, if present.   
 */                                                                   
void open_dev_console(void)                                           
{                                                                     
a0006f2c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  int      stderr_fd;                                                 
                                                                      
  /*                                                                  
   * Attempt to open /dev/console.                                    
   */                                                                 
  if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {         
a0006f30:	e59f004c 	ldr	r0, [pc, #76]	; a0006f84 <open_dev_console+0x5c>
a0006f34:	e1a02001 	mov	r2, r1                                        
a0006f38:	eb000014 	bl	a0006f90 <open>                                
a0006f3c:	e3700001 	cmn	r0, #1                                        
a0006f40:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                
                                                                      
  /*                                                                  
   *  But if we find /dev/console once, we better find it twice more  
   *  or something is REALLY wrong.                                   
   */                                                                 
  if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
a0006f44:	e59f0038 	ldr	r0, [pc, #56]	; a0006f84 <open_dev_console+0x5c><== NOT EXECUTED
a0006f48:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0006f4c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0006f50:	eb00000e 	bl	a0006f90 <open>                                <== NOT EXECUTED
a0006f54:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006f58:	0a000007 	beq	a0006f7c <open_dev_console+0x54>              <== NOT EXECUTED
    rtems_fatal_error_occurred( 0x55544431 );  /* error STD1 */       
                                                                      
  if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
a0006f5c:	e59f0020 	ldr	r0, [pc, #32]	; a0006f84 <open_dev_console+0x5c><== NOT EXECUTED
a0006f60:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0006f64:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0006f68:	eb000008 	bl	a0006f90 <open>                                <== NOT EXECUTED
a0006f6c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006f70:	149df004 	popne	{pc}		; (ldrne pc, [sp], #4)                <== NOT EXECUTED
    rtems_fatal_error_occurred( 0x55544432 );  /* error STD2 */       
a0006f74:	e59f000c 	ldr	r0, [pc, #12]	; a0006f88 <open_dev_console+0x60><== NOT EXECUTED
a0006f78:	eb000c62 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
  /*                                                                  
   *  But if we find /dev/console once, we better find it twice more  
   *  or something is REALLY wrong.                                   
   */                                                                 
  if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)          
    rtems_fatal_error_occurred( 0x55544431 );  /* error STD1 */       
a0006f7c:	e59f0008 	ldr	r0, [pc, #8]	; a0006f8c <open_dev_console+0x64><== NOT EXECUTED
a0006f80:	eb000c60 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0007f00 <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
a0007f00:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
a0007f04:	e5913034 	ldr	r3, [r1, #52]	; 0x34                          <== NOT EXECUTED
/*                                                                    
 * Handle output processing                                           
 */                                                                   
static void                                                           
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
a0007f08:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0007f0c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
a0007f10:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
/*                                                                    
 * Handle output processing                                           
 */                                                                   
static void                                                           
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
a0007f14:	e5cd0000 	strb	r0, [sp]                                     <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
a0007f18:	0a000014 	beq	a0007f70 <oproc+0x70>                         <== NOT EXECUTED
    switch (c) {                                                      
a0007f1c:	e5dd1000 	ldrb	r1, [sp]                                     <== NOT EXECUTED
a0007f20:	e2412008 	sub	r2, r1, #8                                    <== NOT EXECUTED
a0007f24:	e3520005 	cmp	r2, #5                                        <== NOT EXECUTED
a0007f28:	979ff102 	ldrls	pc, [pc, r2, lsl #2]                        <== NOT EXECUTED
a0007f2c:	ea000005 	b	a0007f48 <oproc+0x48>                           <== NOT EXECUTED
a0007f30:	a0007ff8 	.word	0xa0007ff8                                  <== NOT EXECUTED
a0007f34:	a0007fc0 	.word	0xa0007fc0                                  <== NOT EXECUTED
a0007f38:	a000800c 	.word	0xa000800c                                  <== NOT EXECUTED
a0007f3c:	a0007f48 	.word	0xa0007f48                                  <== NOT EXECUTED
a0007f40:	a0007f48 	.word	0xa0007f48                                  <== NOT EXECUTED
a0007f44:	a0007f88 	.word	0xa0007f88                                  <== NOT EXECUTED
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
a0007f48:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a0007f4c:	1a00003a 	bne	a000803c <oproc+0x13c>                        <== NOT EXECUTED
a0007f50:	e59f310c 	ldr	r3, [pc, #268]	; a0008064 <oproc+0x164>       <== NOT EXECUTED
a0007f54:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
        c = toupper(c);                                               
      if (!iscntrl(c))                                                
a0007f58:	e0831001 	add	r1, r3, r1                                    <== NOT EXECUTED
a0007f5c:	e5d13001 	ldrb	r3, [r1, #1]                                 <== NOT EXECUTED
a0007f60:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
        tty->column++;                                                
a0007f64:	05943028 	ldreq	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
a0007f68:	02833001 	addeq	r3, r3, #1                                  <== NOT EXECUTED
a0007f6c:	05843028 	streq	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
a0007f70:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0007f74:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0007f78:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0007f7c:	ebffff99 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
}                                                                     
a0007f80:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0007f84:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
        tty->column = 0;                                              
      }                                                               
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
a0007f88:	e3130010 	tst	r3, #16                                       <== NOT EXECUTED
a0007f8c:	0a000002 	beq	a0007f9c <oproc+0x9c>                         <== NOT EXECUTED
a0007f90:	e5942028 	ldr	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0007f94:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0007f98:	0afffff8 	beq	a0007f80 <oproc+0x80>                         <== NOT EXECUTED
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
a0007f9c:	e2132008 	ands	r2, r3, #8                                   <== NOT EXECUTED
        c = '\n';                                                     
        if (tty->termios.c_oflag & ONLRET)                            
          tty->column = 0;                                            
        break;                                                        
      }                                                               
      tty->column = 0;                                                
a0007fa0:	05842028 	streq	r2, [r4, #40]	; 0x28                        <== NOT EXECUTED
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
a0007fa4:	0afffff1 	beq	a0007f70 <oproc+0x70>                         <== NOT EXECUTED
        c = '\n';                                                     
        if (tty->termios.c_oflag & ONLRET)                            
a0007fa8:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
        c = '\n';                                                     
a0007fac:	e3a0300a 	mov	r3, #10                                       <== NOT EXECUTED
a0007fb0:	e5cd3000 	strb	r3, [sp]                                     <== NOT EXECUTED
        if (tty->termios.c_oflag & ONLRET)                            
          tty->column = 0;                                            
a0007fb4:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0007fb8:	15843028 	strne	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
a0007fbc:	eaffffeb 	b	a0007f70 <oproc+0x70>                           <== NOT EXECUTED
      }                                                               
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
a0007fc0:	e5942028 	ldr	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
a0007fc4:	e2033b06 	and	r3, r3, #6144	; 0x1800                        <== NOT EXECUTED
a0007fc8:	e3530b06 	cmp	r3, #6144	; 0x1800                            <== NOT EXECUTED
      }                                                               
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
a0007fcc:	e2021007 	and	r1, r2, #7                                    <== NOT EXECUTED
a0007fd0:	e2611008 	rsb	r1, r1, #8                                    <== NOT EXECUTED
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
        tty->column += i;                                             
        rtems_termios_puts ( "        ",  i, tty);                    
        return;                                                       
      }                                                               
      tty->column += i;                                               
a0007fd4:	10811002 	addne	r1, r1, r2                                  <== NOT EXECUTED
a0007fd8:	15841028 	strne	r1, [r4, #40]	; 0x28                        <== NOT EXECUTED
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
a0007fdc:	1affffe3 	bne	a0007f70 <oproc+0x70>                         <== NOT EXECUTED
        tty->column += i;                                             
a0007fe0:	e0812002 	add	r2, r1, r2                                    <== NOT EXECUTED
a0007fe4:	e5842028 	str	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
        rtems_termios_puts ( "        ",  i, tty);                    
a0007fe8:	e59f0078 	ldr	r0, [pc, #120]	; a0008068 <oproc+0x168>       <== NOT EXECUTED
a0007fec:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0007ff0:	ebffff7c 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
        return;                                                       
a0007ff4:	eaffffe1 	b	a0007f80 <oproc+0x80>                           <== NOT EXECUTED
      }                                                               
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
a0007ff8:	e5943028 	ldr	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0007ffc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        tty->column--;                                                
a0008000:	c2433001 	subgt	r3, r3, #1                                  <== NOT EXECUTED
a0008004:	c5843028 	strgt	r3, [r4, #40]	; 0x28                        <== NOT EXECUTED
a0008008:	eaffffd8 	b	a0007f70 <oproc+0x70>                           <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
    case '\n':                                                        
      if (tty->termios.c_oflag & ONLRET)                              
a000800c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
        tty->column = 0;                                              
a0008010:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
a0008014:	15842028 	strne	r2, [r4, #40]	; 0x28                        <== NOT EXECUTED
      if (tty->termios.c_oflag & ONLCR) {                             
a0008018:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a000801c:	0affffd3 	beq	a0007f70 <oproc+0x70>                         <== NOT EXECUTED
        rtems_termios_puts ("\r", 1, tty);                            
a0008020:	e59f0044 	ldr	r0, [pc, #68]	; a000806c <oproc+0x16c>        <== NOT EXECUTED
a0008024:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0008028:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000802c:	ebffff6d 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
        tty->column = 0;                                              
a0008030:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0008034:	e5843028 	str	r3, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0008038:	eaffffcc 	b	a0007f70 <oproc+0x70>                           <== NOT EXECUTED
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
        c = toupper(c);                                               
a000803c:	e59f3020 	ldr	r3, [pc, #32]	; a0008064 <oproc+0x164>        <== NOT EXECUTED
a0008040:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0008044:	e0832001 	add	r2, r3, r1                                    <== NOT EXECUTED
a0008048:	e5d22001 	ldrb	r2, [r2, #1]                                 <== NOT EXECUTED
a000804c:	e2022003 	and	r2, r2, #3                                    <== NOT EXECUTED
a0008050:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
a0008054:	02411020 	subeq	r1, r1, #32                                 <== NOT EXECUTED
a0008058:	e20110ff 	and	r1, r1, #255	; 0xff                           <== NOT EXECUTED
a000805c:	e5cd1000 	strb	r1, [sp]                                     <== NOT EXECUTED
a0008060:	eaffffbc 	b	a0007f58 <oproc+0x58>                           <== NOT EXECUTED
                                                                      

a00084b4 <pathconf>: long pathconf( const char *path, int name ) {
a00084b4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a00084b8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_RDONLY );                                        
a00084bc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a00084c0:	ebffff5b 	bl	a0008234 <open>                                <== NOT EXECUTED
  if ( fd == -1 )                                                     
a00084c4:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_RDONLY );                                        
a00084c8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if ( fd == -1 )                                                     
a00084cc:	0a000006 	beq	a00084ec <pathconf+0x38>                      <== NOT EXECUTED
    return -1;                                                        
                                                                      
  status = fpathconf( fd, name );                                     
a00084d0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00084d4:	ebfffaa8 	bl	a0006f7c <fpathconf>                           <== NOT EXECUTED
a00084d8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  (void) close( fd );                                                 
a00084dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00084e0:	ebfff97a 	bl	a0006ad0 <close>                               <== NOT EXECUTED
                                                                      
  return status;                                                      
a00084e4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00084e8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
}                                                                     
a00084ec:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0008784 <pipe>: int pipe( int filsdes[2] ) { if (filsdes == NULL)
a0008784:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
extern int pipe_create(int filsdes[2]);                               
                                                                      
int pipe(                                                             
  int filsdes[2]                                                      
)                                                                     
{                                                                     
a0008788:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  if (filsdes == NULL)                                                
a000878c:	0a000001 	beq	a0008798 <pipe+0x14>                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  return pipe_create(filsdes);                                        
}                                                                     
a0008790:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
)                                                                     
{                                                                     
  if (filsdes == NULL)                                                
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  return pipe_create(filsdes);                                        
a0008794:	ea001c08 	b	a000f7bc <pipe_create>                          <== NOT EXECUTED
int pipe(                                                             
  int filsdes[2]                                                      
)                                                                     
{                                                                     
  if (filsdes == NULL)                                                
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0008798:	eb002832 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a000879c:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a00087a0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  return pipe_create(filsdes);                                        
}                                                                     
a00087a4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00087a8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000f7bc <pipe_create>: * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) {
a000f7bc:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
                                                                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
a000f7c0:	e3a01f7f 	mov	r1, #508	; 0x1fc                              <== NOT EXECUTED
 * Called by pipe() to create an anonymous pipe.                      
 */                                                                   
int pipe_create(                                                      
  int filsdes[2]                                                      
)                                                                     
{                                                                     
a000f7c4:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
a000f7c8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
                                                                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
a000f7cc:	e2811003 	add	r1, r1, #3                                    <== NOT EXECUTED
a000f7d0:	e59f0124 	ldr	r0, [pc, #292]	; a000f8fc <pipe_create+0x140> <== NOT EXECUTED
a000f7d4:	eb0005c9 	bl	a0010f00 <rtems_mkdir>                         <== NOT EXECUTED
a000f7d8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
a000f7dc:	13e03000 	mvnne	r3, #0                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
                                                                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
a000f7e0:	0a000002 	beq	a000f7f0 <pipe_create+0x34>                   <== NOT EXECUTED
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
a000f7e4:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000f7e8:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a000f7ec:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
a000f7f0:	e59fc108 	ldr	ip, [pc, #264]	; a000f900 <pipe_create+0x144> <== NOT EXECUTED
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
a000f7f4:	e59f6108 	ldr	r6, [pc, #264]	; a000f904 <pipe_create+0x148> <== NOT EXECUTED
a000f7f8:	e3a03c6f 	mov	r3, #28416	; 0x6f00                           <== NOT EXECUTED
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
a000f7fc:	e1dc20b0 	ldrh	r2, [ip]                                     <== NOT EXECUTED
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
a000f800:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a000f804:	e286633e 	add	r6, r6, #-134217728	; 0xf8000000              <== NOT EXECUTED
a000f808:	e286673e 	add	r6, r6, #16252928	; 0xf80000                  <== NOT EXECUTED
a000f80c:	e2833066 	add	r3, r3, #102	; 0x66                           <== NOT EXECUTED
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
a000f810:	e282e001 	add	lr, r2, #1                                    <== NOT EXECUTED
a000f814:	e59f10ec 	ldr	r1, [pc, #236]	; a000f908 <pipe_create+0x14c> <== NOT EXECUTED
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
a000f818:	e2866cba 	add	r6, r6, #47616	; 0xba00                       <== NOT EXECUTED
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
a000f81c:	e28d000a 	add	r0, sp, #10                                   <== NOT EXECUTED
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
a000f820:	e58d6004 	str	r6, [sp, #4]                                  <== NOT EXECUTED
a000f824:	e1cd30b8 	strh	r3, [sp, #8]                                 <== NOT EXECUTED
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
a000f828:	e1cce0b0 	strh	lr, [ip]                                     <== NOT EXECUTED
a000f82c:	eb000ecc 	bl	a0013364 <sprintf>                             <== NOT EXECUTED
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
a000f830:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000f834:	e3a01d06 	mov	r1, #384	; 0x180                              <== NOT EXECUTED
a000f838:	eb000508 	bl	a0010c60 <mkfifo>                              <== NOT EXECUTED
a000f83c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
a000f840:	e1a0400d 	mov	r4, sp                                        <== NOT EXECUTED
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
a000f844:	1a000029 	bne	a000f8f0 <pipe_create+0x134>                  <== NOT EXECUTED
    return -1;                                                        
    /* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */           
  }                                                                   
                                                                      
  /* Non-blocking open to avoid waiting for writers */                
  filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);                 
a000f848:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000f84c:	e3a01901 	mov	r1, #16384	; 0x4000                           <== NOT EXECUTED
a000f850:	ebffe32b 	bl	a0008504 <open>                                <== NOT EXECUTED
  if (filsdes[0] < 0) {                                               
a000f854:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
    /* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */           
  }                                                                   
                                                                      
  /* Non-blocking open to avoid waiting for writers */                
  filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);                 
a000f858:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
  if (filsdes[0] < 0) {                                               
a000f85c:	ba000019 	blt	a000f8c8 <pipe_create+0x10c>                  <== NOT EXECUTED
     the file node will be deleted after it is closed by all. */      
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
a000f860:	e59f30a4 	ldr	r3, [pc, #164]	; a000f90c <pipe_create+0x150> <== NOT EXECUTED
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
a000f864:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
     the file node will be deleted after it is closed by all. */      
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
a000f868:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000f86c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000f870:	359f3098 	ldrcc	r3, [pc, #152]	; a000f910 <pipe_create+0x154><== NOT EXECUTED
a000f874:	33a06038 	movcc	r6, #56	; 0x38                              <== NOT EXECUTED
a000f878:	35933000 	ldrcc	r3, [r3]                                    <== NOT EXECUTED
a000f87c:	30263690 	mlacc	r6, r0, r6, r3                              <== NOT EXECUTED
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
a000f880:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
    unlink(fifopath);                                                 
  }                                                                   
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
a000f884:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
a000f888:	e3c33001 	bic	r3, r3, #1                                    <== NOT EXECUTED
a000f88c:	e5863014 	str	r3, [r6, #20]                                 <== NOT EXECUTED
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
a000f890:	ebffe31b 	bl	a0008504 <open>                                <== NOT EXECUTED
                                                                      
    if (filsdes[1] < 0) {                                             
a000f894:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  else {                                                              
  /* Reset open file to blocking mode */                              
    iop = rtems_libio_iop(filsdes[0]);                                
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
a000f898:	e5850004 	str	r0, [r5, #4]                                  <== NOT EXECUTED
int pipe_create(                                                      
  int filsdes[2]                                                      
)                                                                     
{                                                                     
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
a000f89c:	a3a06000 	movge	r6, #0                                      <== NOT EXECUTED
    iop = rtems_libio_iop(filsdes[0]);                                
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
                                                                      
    if (filsdes[1] < 0) {                                             
a000f8a0:	ba00000d 	blt	a000f8dc <pipe_create+0x120>                  <== NOT EXECUTED
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
a000f8a4:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000f8a8:	ebffeb59 	bl	a000a614 <unlink>                              <== NOT EXECUTED
  }                                                                   
  if(err != 0)                                                        
a000f8ac:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
a000f8b0:	01a03006 	moveq	r3, r6                                      <== NOT EXECUTED
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
a000f8b4:	0affffca 	beq	a000f7e4 <pipe_create+0x28>                   <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one(err);                        
a000f8b8:	eb000bea 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a000f8bc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a000f8c0:	e5806000 	str	r6, [r0]                                      <== NOT EXECUTED
a000f8c4:	eaffffc6 	b	a000f7e4 <pipe_create+0x28>                     <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Non-blocking open to avoid waiting for writers */                
  filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);                 
  if (filsdes[0] < 0) {                                               
    err = errno;                                                      
a000f8c8:	eb000be6 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a000f8cc:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
    /* Delete file at errors, or else if pipe is successfully created 
     the file node will be deleted after it is closed by all. */      
    unlink(fifopath);                                                 
a000f8d0:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000f8d4:	ebffeb4e 	bl	a000a614 <unlink>                              <== NOT EXECUTED
a000f8d8:	eafffff3 	b	a000f8ac <pipe_create+0xf0>                     <== NOT EXECUTED
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
                                                                      
    if (filsdes[1] < 0) {                                             
    err = errno;                                                      
a000f8dc:	eb000be1 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a000f8e0:	e5906000 	ldr	r6, [r0]                                      <== NOT EXECUTED
    close(filsdes[0]);                                                
a000f8e4:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000f8e8:	ebffdeb2 	bl	a00073b8 <close>                               <== NOT EXECUTED
a000f8ec:	eaffffec 	b	a000f8a4 <pipe_create+0xe8>                     <== NOT EXECUTED
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
    if (errno != EEXIST){                                             
a000f8f0:	eb000bdc 	bl	a0012868 <__errno>                             <== NOT EXECUTED
      return -1;                                                      
a000f8f4:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a000f8f8:	eaffffb9 	b	a000f7e4 <pipe_create+0x28>                     <== NOT EXECUTED
                                                                      

a0010dd0 <pipe_ioctl>: uint32_t cmd, void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) {
a0010dd0:	e59f3060 	ldr	r3, [pc, #96]	; a0010e38 <pipe_ioctl+0x68>    <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  uint32_t        cmd,                                                
  void           *buffer,                                             
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
a0010dd4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if (cmd == FIONREAD) {                                              
a0010dd8:	e1510003 	cmp	r1, r3                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  uint32_t        cmd,                                                
  void           *buffer,                                             
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
a0010ddc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0010de0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  if (cmd == FIONREAD) {                                              
a0010de4:	0a000001 	beq	a0010df0 <pipe_ioctl+0x20>                    <== NOT EXECUTED
    *(unsigned int *)buffer = pipe->Length;                           
    PIPE_UNLOCK(pipe);                                                
    return 0;                                                         
  }                                                                   
                                                                      
  return -EINVAL;                                                     
a0010de8:	e3e00015 	mvn	r0, #21                                       <== NOT EXECUTED
a0010dec:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  void           *buffer,                                             
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
  if (cmd == FIONREAD) {                                              
    if (buffer == NULL)                                               
a0010df0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0010df4:	1a000001 	bne	a0010e00 <pipe_ioctl+0x30>                    <== NOT EXECUTED
      return -EFAULT;                                                 
a0010df8:	e3e0000d 	mvn	r0, #13                                       <== NOT EXECUTED
a0010dfc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
    if (! PIPE_LOCK(pipe))                                            
a0010e00:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010e04:	e5900028 	ldr	r0, [r0, #40]	; 0x28                          <== NOT EXECUTED
a0010e08:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0010e0c:	ebffeb86 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010e10:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0010e14:	0a000001 	beq	a0010e20 <pipe_ioctl+0x50>                    <== NOT EXECUTED
      return -EINTR;                                                  
a0010e18:	e3e00003 	mvn	r0, #3                                        <== NOT EXECUTED
    PIPE_UNLOCK(pipe);                                                
    return 0;                                                         
  }                                                                   
                                                                      
  return -EINVAL;                                                     
}                                                                     
a0010e1c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
a0010e20:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
    PIPE_UNLOCK(pipe);                                                
a0010e24:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
a0010e28:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    PIPE_UNLOCK(pipe);                                                
a0010e2c:	ebffebc7 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
    return 0;                                                         
a0010e30:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010e34:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0010e3c <pipe_lseek>: rtems_libio_t *iop ) { /* Seek on pipe is not supported */ return -ESPIPE; }
a0010e3c:	e3e0001c 	mvn	r0, #28                                       <== NOT EXECUTED
a0010e40:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010a1c <pipe_read>: pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) {
a0010a1c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0010a20:	e1a09001 	mov	r9, r1                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010a24:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  void           *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
a0010a28:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0010a2c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0010a30:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010a34:	e5900028 	ldr	r0, [r0, #40]	; 0x28                          <== NOT EXECUTED
a0010a38:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  void           *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
a0010a3c:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010a40:	ebffec79 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010a44:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
    return -EINTR;                                                    
a0010a48:	13e00003 	mvnne	r0, #3                                      <== NOT EXECUTED
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010a4c:	1a000028 	bne	a0010af4 <pipe_read+0xd8>                     <== NOT EXECUTED
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
a0010a50:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0010a54:	01a08005 	moveq	r8, r5                                      <== NOT EXECUTED
a0010a58:	01a06008 	moveq	r6, r8                                      <== NOT EXECUTED
a0010a5c:	0a00001f 	beq	a0010ae0 <pipe_read+0xc4>                     <== NOT EXECUTED
a0010a60:	e1a0800a 	mov	r8, sl                                        <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
                                                                      
    if (pipe->waitingWriters > 0)                                     
      PIPE_WAKEUPWRITERS(pipe);                                       
a0010a64:	e28db004 	add	fp, sp, #4                                    <== NOT EXECUTED
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    while (PIPE_EMPTY(pipe)) {                                        
a0010a68:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
a0010a6c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0010a70:	1a000021 	bne	a0010afc <pipe_read+0xe0>                     <== NOT EXECUTED
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
a0010a74:	e5946014 	ldr	r6, [r4, #20]                                 <== NOT EXECUTED
a0010a78:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0010a7c:	0a000017 	beq	a0010ae0 <pipe_read+0xc4>                     <== NOT EXECUTED
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
a0010a80:	e5976014 	ldr	r6, [r7, #20]                                 <== NOT EXECUTED
a0010a84:	e2166001 	ands	r6, r6, #1                                   <== NOT EXECUTED
a0010a88:	1a00003a 	bne	a0010b78 <pipe_read+0x15c>                    <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
a0010a8c:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
a0010a90:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
a0010a94:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0010a98:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
a0010a9c:	ebffecab 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
      if (! PIPE_READWAIT(pipe))                                      
a0010aa0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010aa4:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
a0010aa8:	eb0003eb 	bl	a0011a5c <rtems_barrier_wait>                  <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010aac:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010ab0:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
a0010ab4:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010ab8:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
      }                                                               
                                                                      
      /* Wait until pipe is no more empty or no writer exists */      
      pipe->waitingReaders ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
a0010abc:	13e06003 	mvnne	r6, #3                                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010ac0:	ebffec59 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010ac4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010ac8:	1a00002c 	bne	a0010b80 <pipe_read+0x164>                    <== NOT EXECUTED
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
a0010acc:	e5943018 	ldr	r3, [r4, #24]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
a0010ad0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
a0010ad4:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0010ad8:	e5843018 	str	r3, [r4, #24]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
a0010adc:	0affffe1 	beq	a0010a68 <pipe_read+0x4c>                     <== NOT EXECUTED
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
a0010ae0:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0010ae4:	ebffec99 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
a0010ae8:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a0010aec:	c1a00008 	movgt	r0, r8                                      <== NOT EXECUTED
a0010af0:	d1a00006 	movle	r0, r6                                      <== NOT EXECUTED
    return read;                                                      
  return ret;                                                         
}                                                                     
a0010af4:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0010af8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    chunk1 = pipe->Size - pipe->Start;                                
a0010afc:	e9941008 	ldmib	r4, {r3, ip}                                <== NOT EXECUTED
      if (ret != 0)                                                   
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
a0010b00:	e06a6005 	rsb	r6, sl, r5                                    <== NOT EXECUTED
a0010b04:	e1520006 	cmp	r2, r6                                        <== NOT EXECUTED
a0010b08:	31a06002 	movcc	r6, r2                                      <== NOT EXECUTED
    chunk1 = pipe->Size - pipe->Start;                                
a0010b0c:	e06c3003 	rsb	r3, ip, r3                                    <== NOT EXECUTED
    if (chunk > chunk1) {                                             
a0010b10:	e1560003 	cmp	r6, r3                                        <== NOT EXECUTED
a0010b14:	ca00001b 	bgt	a0010b88 <pipe_read+0x16c>                    <== NOT EXECUTED
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
a0010b18:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
a0010b1c:	e089000a 	add	r0, r9, sl                                    <== NOT EXECUTED
a0010b20:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0010b24:	e081100c 	add	r1, r1, ip                                    <== NOT EXECUTED
a0010b28:	eb000d4f 	bl	a001406c <memcpy>                              <== NOT EXECUTED
                                                                      
    pipe->Start += chunk;                                             
a0010b2c:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
    pipe->Start %= pipe->Size;                                        
a0010b30:	e5941004 	ldr	r1, [r4, #4]                                  <== NOT EXECUTED
a0010b34:	e0860000 	add	r0, r6, r0                                    <== NOT EXECUTED
a0010b38:	eb003c5a 	bl	a001fca8 <__umodsi3>                           <== NOT EXECUTED
    pipe->Length -= chunk;                                            
a0010b3c:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
a0010b40:	e5840008 	str	r0, [r4, #8]                                  <== NOT EXECUTED
    pipe->Length -= chunk;                                            
a0010b44:	e0663003 	rsb	r3, r6, r3                                    <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
a0010b48:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      pipe->Start = 0;                                                
a0010b4c:	05843008 	streq	r3, [r4, #8]                                <== NOT EXECUTED
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
    pipe->Length -= chunk;                                            
a0010b50:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
                                                                      
    if (pipe->waitingWriters > 0)                                     
a0010b54:	e594301c 	ldr	r3, [r4, #28]                                 <== NOT EXECUTED
a0010b58:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010b5c:	1a000016 	bne	a0010bbc <pipe_read+0x1a0>                    <== NOT EXECUTED
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
a0010b60:	e0888006 	add	r8, r8, r6                                    <== NOT EXECUTED
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
a0010b64:	e1580005 	cmp	r8, r5                                        <== NOT EXECUTED
a0010b68:	e1a0a008 	mov	sl, r8                                        <== NOT EXECUTED
a0010b6c:	3affffbd 	bcc	a0010a68 <pipe_read+0x4c>                     <== NOT EXECUTED
a0010b70:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0010b74:	eaffffd9 	b	a0010ae0 <pipe_read+0xc4>                       <== NOT EXECUTED
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
        ret = -EAGAIN;                                                
a0010b78:	e3e0600a 	mvn	r6, #10                                       <== NOT EXECUTED
a0010b7c:	eaffffd7 	b	a0010ae0 <pipe_read+0xc4>                       <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
a0010b80:	e3e06003 	mvn	r6, #3                                        <== NOT EXECUTED
a0010b84:	eaffffd7 	b	a0010ae8 <pipe_read+0xcc>                       <== NOT EXECUTED
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    chunk1 = pipe->Size - pipe->Start;                                
    if (chunk > chunk1) {                                             
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
a0010b88:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
a0010b8c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0010b90:	e089000a 	add	r0, r9, sl                                    <== NOT EXECUTED
a0010b94:	e081100c 	add	r1, r1, ip                                    <== NOT EXECUTED
a0010b98:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010b9c:	eb000d32 	bl	a001406c <memcpy>                              <== NOT EXECUTED
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
a0010ba0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0010ba4:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
a0010ba8:	e08a0003 	add	r0, sl, r3                                    <== NOT EXECUTED
a0010bac:	e0890000 	add	r0, r9, r0                                    <== NOT EXECUTED
a0010bb0:	e0632006 	rsb	r2, r3, r6                                    <== NOT EXECUTED
a0010bb4:	eb000d2c 	bl	a001406c <memcpy>                              <== NOT EXECUTED
a0010bb8:	eaffffdb 	b	a0010b2c <pipe_read+0x110>                      <== NOT EXECUTED
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
      pipe->Start = 0;                                                
                                                                      
    if (pipe->waitingWriters > 0)                                     
      PIPE_WAKEUPWRITERS(pipe);                                       
a0010bbc:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
a0010bc0:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a0010bc4:	eb00038c 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010bc8:	eaffffe4 	b	a0010b60 <pipe_read+0x144>                      <== NOT EXECUTED
                                                                      

a0010500 <pipe_release>: */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) {
a0010500:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
    /* WARN pipe not released! */                                     
    if (!PIPE_LOCK(pipe))                                             
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
a0010504:	e5915014 	ldr	r5, [r1, #20]                                 <== NOT EXECUTED
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
  pipe_control_t *pipe = *pipep;                                      
a0010508:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
 */                                                                   
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a001050c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
    if (!PIPE_LOCK(pipe))                                             
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
  if (mode & LIBIO_FLAGS_READ)                                        
a0010510:	e3150002 	tst	r5, #2                                        <== NOT EXECUTED
     pipe->Readers --;                                                
a0010514:	15943010 	ldrne	r3, [r4, #16]                               <== NOT EXECUTED
    /* WARN pipe not released! */                                     
    if (!PIPE_LOCK(pipe))                                             
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
a0010518:	e2055006 	and	r5, r5, #6                                    <== NOT EXECUTED
 */                                                                   
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
a001051c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
      rtems_fatal_error_occurred(0xdeadbeef);                         
  #endif                                                              
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
  if (mode & LIBIO_FLAGS_READ)                                        
     pipe->Readers --;                                                
a0010520:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
a0010524:	15843010 	strne	r3, [r4, #16]                               <== NOT EXECUTED
  if (mode & LIBIO_FLAGS_WRITE)                                       
a0010528:	e3150004 	tst	r5, #4                                        <== NOT EXECUTED
     pipe->Writers --;                                                
a001052c:	15943014 	ldrne	r3, [r4, #20]                               <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
a0010530:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  mode = LIBIO_ACCMODE(iop);                                          
  if (mode & LIBIO_FLAGS_READ)                                        
     pipe->Readers --;                                                
  if (mode & LIBIO_FLAGS_WRITE)                                       
     pipe->Writers --;                                                
a0010534:	12433001 	subne	r3, r3, #1                                  <== NOT EXECUTED
a0010538:	15843014 	strne	r3, [r4, #20]                               <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
a001053c:	ebffee03 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
a0010540:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
a0010544:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010548:	1a000007 	bne	a001056c <pipe_release+0x6c>                  <== NOT EXECUTED
a001054c:	e5947014 	ldr	r7, [r4, #20]                                 <== NOT EXECUTED
a0010550:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0010554:	0a000013 	beq	a00105a8 <pipe_release+0xa8>                  <== NOT EXECUTED
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
a0010558:	e3550004 	cmp	r5, #4                                        <== NOT EXECUTED
a001055c:	1a00000d 	bne	a0010598 <pipe_release+0x98>                  <== NOT EXECUTED
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
  else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)            
    PIPE_WAKEUPREADERS(pipe);                                         
                                                                      
  pipe_unlock();                                                      
a0010560:	ebffffe2 	bl	a00104f0 <pipe_unlock>                         <== NOT EXECUTED
  iop->flags &= ~LIBIO_FLAGS_OPEN;                                    
  if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))                     
    return;                                                           
#endif                                                                
                                                                      
}                                                                     
a0010564:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0010568:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
  else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)            
a001056c:	e5943014 	ldr	r3, [r4, #20]                                 <== NOT EXECUTED
a0010570:	e2733001 	rsbs	r3, r3, #1                                   <== NOT EXECUTED
a0010574:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
a0010578:	e3550002 	cmp	r5, #2                                        <== NOT EXECUTED
a001057c:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a0010580:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010584:	0afffff5 	beq	a0010560 <pipe_release+0x60>                  <== NOT EXECUTED
    PIPE_WAKEUPREADERS(pipe);                                         
a0010588:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
a001058c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010590:	eb000519 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010594:	eafffff1 	b	a0010560 <pipe_release+0x60>                    <== NOT EXECUTED
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
a0010598:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
a001059c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00105a0:	eb000515 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a00105a4:	eaffffed 	b	a0010560 <pipe_release+0x60>                    <== NOT EXECUTED
/* Called with pipe_semaphore held. */                                
static inline void pipe_free(                                         
  pipe_control_t *pipe                                                
)                                                                     
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
a00105a8:	e594002c 	ldr	r0, [r4, #44]	; 0x2c                          <== NOT EXECUTED
a00105ac:	eb0004e6 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
  rtems_barrier_delete(pipe->writeBarrier);                           
a00105b0:	e5940030 	ldr	r0, [r4, #48]	; 0x30                          <== NOT EXECUTED
a00105b4:	eb0004e4 	bl	a001194c <rtems_barrier_delete>                <== NOT EXECUTED
  rtems_semaphore_delete(pipe->Semaphore);                            
a00105b8:	e5940028 	ldr	r0, [r4, #40]	; 0x28                          <== NOT EXECUTED
a00105bc:	ebffed71 	bl	a000bb88 <rtems_semaphore_delete>              <== NOT EXECUTED
  free(pipe->Buffer);                                                 
a00105c0:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a00105c4:	ebffde65 	bl	a0007f60 <free>                                <== NOT EXECUTED
  free(pipe);                                                         
a00105c8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00105cc:	ebffde63 	bl	a0007f60 <free>                                <== NOT EXECUTED
    /* To delete an anonymous pipe file when all users closed it */   
    if (pipe->Anonymous)                                              
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
a00105d0:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
a00105d4:	eaffffe1 	b	a0010560 <pipe_release+0x60>                    <== NOT EXECUTED
                                                                      

a00104f0 <pipe_unlock>: static void pipe_unlock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; sc = rtems_semaphore_release(pipe_semaphore);
a00104f0:	e59f3004 	ldr	r3, [pc, #4]	; a00104fc <pipe_unlock+0xc>     <== NOT EXECUTED
a00104f4:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a00104f8:	eaffee14 	b	a000bd50 <rtems_semaphore_release>              <== NOT EXECUTED
                                                                      

a0010bcc <pipe_write>: pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) {
a0010bcc:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
a0010bd0:	e2524000 	subs	r4, r2, #0                                   <== NOT EXECUTED
  pipe_control_t *pipe,                                               
  const void     *buffer,                                             
  size_t          count,                                              
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
a0010bd4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0010bd8:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0010bdc:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
a0010be0:	01a00004 	moveq	r0, r4                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
a0010be4:	1a000001 	bne	a0010bf0 <pipe_write+0x24>                    <== NOT EXECUTED
#endif                                                                
                                                                      
  if (written > 0)                                                    
    return written;                                                   
  return ret;                                                         
}                                                                     
a0010be8:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0010bec:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010bf0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010bf4:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010bf8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0010bfc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010c00:	ebffec09 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010c04:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
a0010c08:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    return -EINTR;                                                    
a0010c0c:	13e00003 	mvnne	r0, #3                                      <== NOT EXECUTED
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
a0010c10:	1afffff4 	bne	a0010be8 <pipe_write+0x1c>                    <== NOT EXECUTED
    return -EINTR;                                                    
                                                                      
  if (pipe->Readers == 0) {                                           
a0010c14:	e595a010 	ldr	sl, [r5, #16]                                 <== NOT EXECUTED
a0010c18:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
a0010c1c:	0a000057 	beq	a0010d80 <pipe_write+0x1b4>                   <== NOT EXECUTED
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
a0010c20:	e5957004 	ldr	r7, [r5, #4]                                  <== NOT EXECUTED
a0010c24:	e1a0a009 	mov	sl, r9                                        <== NOT EXECUTED
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
a0010c28:	e28db004 	add	fp, sp, #4                                    <== NOT EXECUTED
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
a0010c2c:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
a0010c30:	91a08004 	movls	r8, r4                                      <== NOT EXECUTED
a0010c34:	83a08001 	movhi	r8, #1                                      <== NOT EXECUTED
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
a0010c38:	e595000c 	ldr	r0, [r5, #12]                                 <== NOT EXECUTED
a0010c3c:	e0602007 	rsb	r2, r0, r7                                    <== NOT EXECUTED
a0010c40:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
a0010c44:	2a000021 	bcs	a0010cd0 <pipe_write+0x104>                   <== NOT EXECUTED
      if (LIBIO_NODELAY(iop)) {                                       
a0010c48:	e5937014 	ldr	r7, [r3, #20]                                 <== NOT EXECUTED
a0010c4c:	e2177001 	ands	r7, r7, #1                                   <== NOT EXECUTED
a0010c50:	1a00004e 	bne	a0010d90 <pipe_write+0x1c4>                   <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
a0010c54:	e595201c 	ldr	r2, [r5, #28]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
a0010c58:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
        ret = -EAGAIN;                                                
        goto out_locked;                                              
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
a0010c5c:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0010c60:	e585201c 	str	r2, [r5, #28]                                 <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
a0010c64:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010c68:	ebffec38 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
      if (! PIPE_WRITEWAIT(pipe))                                     
a0010c6c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010c70:	e5950030 	ldr	r0, [r5, #48]	; 0x30                          <== NOT EXECUTED
a0010c74:	eb000378 	bl	a0011a5c <rtems_barrier_wait>                  <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010c78:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0010c7c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
a0010c80:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010c84:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
      }                                                               
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
a0010c88:	13e07003 	mvnne	r7, #3                                      <== NOT EXECUTED
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
a0010c8c:	ebffebe6 	bl	a000bc2c <rtems_semaphore_obtain>              <== NOT EXECUTED
a0010c90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010c94:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0010c98:	1a00003a 	bne	a0010d88 <pipe_write+0x1bc>                   <== NOT EXECUTED
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
a0010c9c:	e595201c 	ldr	r2, [r5, #28]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
a0010ca0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
a0010ca4:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
a0010ca8:	e585201c 	str	r2, [r5, #28]                                 <== NOT EXECUTED
      if (ret != 0)                                                   
a0010cac:	1a00002d 	bne	a0010d68 <pipe_write+0x19c>                   <== NOT EXECUTED
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
a0010cb0:	e5952010 	ldr	r2, [r5, #16]                                 <== NOT EXECUTED
a0010cb4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0010cb8:	0a000030 	beq	a0010d80 <pipe_write+0x1b4>                   <== NOT EXECUTED
a0010cbc:	e5957004 	ldr	r7, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
a0010cc0:	e595000c 	ldr	r0, [r5, #12]                                 <== NOT EXECUTED
a0010cc4:	e0602007 	rsb	r2, r0, r7                                    <== NOT EXECUTED
a0010cc8:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
a0010ccc:	3affffdd 	bcc	a0010c48 <pipe_write+0x7c>                    <== NOT EXECUTED
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
a0010cd0:	e595c008 	ldr	ip, [r5, #8]                                  <== NOT EXECUTED
a0010cd4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
a0010cd8:	e0698004 	rsb	r8, r9, r4                                    <== NOT EXECUTED
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
a0010cdc:	e080000c 	add	r0, r0, ip                                    <== NOT EXECUTED
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
a0010ce0:	e1520008 	cmp	r2, r8                                        <== NOT EXECUTED
a0010ce4:	31a08002 	movcc	r8, r2                                      <== NOT EXECUTED
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
a0010ce8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010cec:	eb003bed 	bl	a001fca8 <__umodsi3>                           <== NOT EXECUTED
a0010cf0:	e0607007 	rsb	r7, r0, r7                                    <== NOT EXECUTED
    if (chunk > chunk1) {                                             
a0010cf4:	e1580007 	cmp	r8, r7                                        <== NOT EXECUTED
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
a0010cf8:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
    if (chunk > chunk1) {                                             
a0010cfc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0010d00:	da000024 	ble	a0010d98 <pipe_write+0x1cc>                   <== NOT EXECUTED
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
a0010d04:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0010d08:	e0861009 	add	r1, r6, r9                                    <== NOT EXECUTED
a0010d0c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0010d10:	e080000c 	add	r0, r0, ip                                    <== NOT EXECUTED
a0010d14:	eb000cd4 	bl	a001406c <memcpy>                              <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
a0010d18:	e0871009 	add	r1, r7, r9                                    <== NOT EXECUTED
a0010d1c:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0010d20:	e0861001 	add	r1, r6, r1                                    <== NOT EXECUTED
a0010d24:	e0672008 	rsb	r2, r7, r8                                    <== NOT EXECUTED
a0010d28:	eb000ccf 	bl	a001406c <memcpy>                              <== NOT EXECUTED
a0010d2c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
a0010d30:	e595200c 	ldr	r2, [r5, #12]                                 <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
a0010d34:	e5951018 	ldr	r1, [r5, #24]                                 <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
a0010d38:	e0822008 	add	r2, r2, r8                                    <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
a0010d3c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
a0010d40:	e585200c 	str	r2, [r5, #12]                                 <== NOT EXECUTED
    if (pipe->waitingReaders > 0)                                     
a0010d44:	1a00001b 	bne	a0010db8 <pipe_write+0x1ec>                   <== NOT EXECUTED
      PIPE_WAKEUPREADERS(pipe);                                       
    written += chunk;                                                 
a0010d48:	e08aa008 	add	sl, sl, r8                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
a0010d4c:	e154000a 	cmp	r4, sl                                        <== NOT EXECUTED
a0010d50:	e1a0900a 	mov	r9, sl                                        <== NOT EXECUTED
a0010d54:	9a000002 	bls	a0010d64 <pipe_write+0x198>                   <== NOT EXECUTED
a0010d58:	e5957004 	ldr	r7, [r5, #4]                                  <== NOT EXECUTED
    pipe->Length += chunk;                                            
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
    written += chunk;                                                 
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
a0010d5c:	e3a08001 	mov	r8, #1                                        <== NOT EXECUTED
a0010d60:	eaffffb4 	b	a0010c38 <pipe_write+0x6c>                      <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
a0010d64:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
a0010d68:	e5950028 	ldr	r0, [r5, #40]	; 0x28                          <== NOT EXECUTED
a0010d6c:	ebffebf7 	bl	a000bd50 <rtems_semaphore_release>             <== NOT EXECUTED
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
#endif                                                                
                                                                      
  if (written > 0)                                                    
a0010d70:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
a0010d74:	c1a0000a 	movgt	r0, sl                                      <== NOT EXECUTED
a0010d78:	d1a00007 	movle	r0, r7                                      <== NOT EXECUTED
a0010d7c:	eaffff99 	b	a0010be8 <pipe_write+0x1c>                      <== NOT EXECUTED
      pipe->waitingWriters --;                                        
      if (ret != 0)                                                   
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
        ret = -EPIPE;                                                 
a0010d80:	e3e0701f 	mvn	r7, #31                                       <== NOT EXECUTED
a0010d84:	eafffff7 	b	a0010d68 <pipe_write+0x19c>                     <== NOT EXECUTED
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
a0010d88:	e3e07003 	mvn	r7, #3                                        <== NOT EXECUTED
a0010d8c:	eafffff7 	b	a0010d70 <pipe_write+0x1a4>                     <== NOT EXECUTED
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
      if (LIBIO_NODELAY(iop)) {                                       
        ret = -EAGAIN;                                                
a0010d90:	e3e0700a 	mvn	r7, #10                                       <== NOT EXECUTED
a0010d94:	eafffff3 	b	a0010d68 <pipe_write+0x19c>                     <== NOT EXECUTED
    if (chunk > chunk1) {                                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
a0010d98:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0010d9c:	e0861009 	add	r1, r6, r9                                    <== NOT EXECUTED
a0010da0:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a0010da4:	e080000c 	add	r0, r0, ip                                    <== NOT EXECUTED
a0010da8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010dac:	eb000cae 	bl	a001406c <memcpy>                              <== NOT EXECUTED
a0010db0:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0010db4:	eaffffdd 	b	a0010d30 <pipe_write+0x164>                     <== NOT EXECUTED
                                                                      
    pipe->Length += chunk;                                            
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
a0010db8:	e595002c 	ldr	r0, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a0010dbc:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a0010dc0:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0010dc4:	eb00030c 	bl	a00119fc <rtems_barrier_release>               <== NOT EXECUTED
a0010dc8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0010dcc:	eaffffdd 	b	a0010d48 <pipe_write+0x17c>                     <== NOT EXECUTED
                                                                      

a000b464 <posix_memalign>: ) { /* * Update call statistics */ MSBUMP(memalign_calls, 1);
a000b464:	e59fc044 	ldr	ip, [pc, #68]	; a000b4b0 <posix_memalign+0x4c><== NOT EXECUTED
int posix_memalign(                                                   
  void   **pointer,                                                   
  size_t   alignment,                                                 
  size_t   size                                                       
)                                                                     
{                                                                     
a000b468:	e92d0030 	push	{r4, r5}                                     <== NOT EXECUTED
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
a000b46c:	e2414001 	sub	r4, r1, #1                                    <== NOT EXECUTED
a000b470:	e1140001 	tst	r4, r1                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
a000b474:	e59c4008 	ldr	r4, [ip, #8]                                  <== NOT EXECUTED
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
a000b478:	03a05000 	moveq	r5, #0                                      <== NOT EXECUTED
a000b47c:	13a05001 	movne	r5, #1                                      <== NOT EXECUTED
a000b480:	e3510003 	cmp	r1, #3                                        <== NOT EXECUTED
a000b484:	81a03005 	movhi	r3, r5                                      <== NOT EXECUTED
a000b488:	93853001 	orrls	r3, r5, #1                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
a000b48c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
a000b490:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
a000b494:	e58c4008 	str	r4, [ip, #8]                                  <== NOT EXECUTED
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
a000b498:	0a000002 	beq	a000b4a8 <posix_memalign+0x44>                <== NOT EXECUTED
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
}                                                                     
a000b49c:	e3a00016 	mov	r0, #22                                       <== NOT EXECUTED
a000b4a0:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
a000b4a4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
a000b4a8:	e8bd0030 	pop	{r4, r5}                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  rtems_memalign does all of the error checking work EXCEPT       
   *  for adding restrictionso on the alignment.                      
   */                                                                 
  return rtems_memalign( pointer, alignment, size );                  
a000b4ac:	ea000080 	b	a000b6b4 <rtems_memalign>                       <== NOT EXECUTED
                                                                      

a0008670 <printk_plugin>: int printk_plugin( void *ignored __attribute__((unused)), const char *format, ... ) {
a0008670:	e92d000e 	push	{r1, r2, r3}                                 <== NOT EXECUTED
a0008674:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0008678:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  va_list arg_pointer;                                                
                                                                      
  va_start (arg_pointer, format);                                     
a000867c:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
                                                                      
  vprintk( format, arg_pointer );                                     
a0008680:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
a0008684:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
  ...                                                                 
)                                                                     
{                                                                     
  va_list arg_pointer;                                                
                                                                      
  va_start (arg_pointer, format);                                     
a0008688:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
                                                                      
  vprintk( format, arg_pointer );                                     
a000868c:	eb00077e 	bl	a000a48c <vprintk>                             <== NOT EXECUTED
                                                                      
  va_end(arg_pointer); /* clean up when done */                       
                                                                      
  return 0;                                                           
}                                                                     
a0008690:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0008694:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0008698:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
a000869c:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a00086a0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00160d0 <read>: ) { ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd );
a00160d0:	e59f30a8 	ldr	r3, [pc, #168]	; a0016180 <read+0xb0>         <== NOT EXECUTED
ssize_t read(                                                         
  int         fd,                                                     
  void       *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
a00160d4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  ssize_t      rc;                                                    
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a00160d8:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
ssize_t read(                                                         
  int         fd,                                                     
  void       *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
a00160dc:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  ssize_t      rc;                                                    
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
a00160e0:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
a00160e4:	2a00001b 	bcs	a0016158 <read+0x88>                          <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a00160e8:	e59fc094 	ldr	ip, [pc, #148]	; a0016184 <read+0xb4>         <== NOT EXECUTED
a00160ec:	e3a04038 	mov	r4, #56	; 0x38                                <== NOT EXECUTED
a00160f0:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a00160f4:	e024c490 	mla	r4, r0, r4, ip                                <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
a00160f8:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a00160fc:	e3100c01 	tst	r0, #256	; 0x100                              <== NOT EXECUTED
a0016100:	0a000014 	beq	a0016158 <read+0x88>                          <== NOT EXECUTED
  rtems_libio_check_buffer( buffer );                                 
a0016104:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0016108:	0a000017 	beq	a001616c <read+0x9c>                          <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
a001610c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0016110:	0a00000e 	beq	a0016150 <read+0x80>                          <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );             
a0016114:	e3100002 	tst	r0, #2                                        <== NOT EXECUTED
a0016118:	0a000013 	beq	a001616c <read+0x9c>                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
  rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );       
a001611c:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a0016120:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0016124:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0016128:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  if ( rc > 0 )                                                       
a001612c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0016130:	da000007 	ble	a0016154 <read+0x84>                          <== NOT EXECUTED
    iop->offset += rc;                                                
a0016134:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
a0016138:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a001613c:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
a0016140:	e0a33fc0 	adc	r3, r3, r0, asr #31                           <== NOT EXECUTED
a0016144:	e584200c 	str	r2, [r4, #12]                                 <== NOT EXECUTED
a0016148:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
a001614c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
a0016150:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
                                                                      
  if ( rc > 0 )                                                       
    iop->offset += rc;                                                
                                                                      
  return rc;                                                          
}                                                                     
a0016154:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  ssize_t      rc;                                                    
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
a0016158:	ebffebe0 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a001615c:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0016160:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0016164:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0016168:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );             
a001616c:	ebffebdb 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0016170:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0016174:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0016178:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a001617c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a00098fc <readlink>: ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) {
a00098fc:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
a0009900:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
ssize_t readlink(                                                     
  const char *pathname,                                               
  char       *buf,                                                    
  size_t      bufsize                                                 
)                                                                     
{                                                                     
a0009904:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0009908:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a000990c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
a0009910:	0a00001d 	beq	a000998c <readlink+0x90>                      <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
a0009914:	eb003168 	bl	a0015ebc <strlen>                              <== NOT EXECUTED
a0009918:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a000991c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0009920:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0009924:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0009928:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000992c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0009930:	ebfffb61 	bl	a00086bc <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                           0, &loc, false );          
  if ( result != 0 )                                                  
a0009934:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
     return -1;                                                       
a0009938:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
  if (!buf)                                                           
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
                                           0, &loc, false );          
  if ( result != 0 )                                                  
a000993c:	0a000001 	beq	a0009948 <readlink+0x4c>                      <== NOT EXECUTED
  result =  (*loc.ops->readlink_h)( &loc, buf, bufsize );             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
                                                                      
  return result;                                                      
}                                                                     
a0009940:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0009944:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
                                           0, &loc, false );          
  if ( result != 0 )                                                  
     return -1;                                                       
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
a0009948:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000994c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009950:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a0009954:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0009958:	e3500004 	cmp	r0, #4                                        <== NOT EXECUTED
a000995c:	1a00000f 	bne	a00099a0 <readlink+0xa4>                      <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  result =  (*loc.ops->readlink_h)( &loc, buf, bufsize );             
a0009960:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0009964:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0009968:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000996c:	e593303c 	ldr	r3, [r3, #60]	; 0x3c                          <== NOT EXECUTED
a0009970:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009974:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0009978:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a000997c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009980:	ebfffb87 	bl	a00087a4 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
a0009984:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009988:	eaffffec 	b	a0009940 <readlink+0x44>                        <== NOT EXECUTED
{                                                                     
  rtems_filesystem_location_info_t  loc;                              
  int                               result;                           
                                                                      
  if (!buf)                                                           
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a000998c:	eb0029ff 	bl	a0014190 <__errno>                             <== NOT EXECUTED
a0009990:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a0009994:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0009998:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000999c:	eaffffe7 	b	a0009940 <readlink+0x44>                        <== NOT EXECUTED
                                           0, &loc, false );          
  if ( result != 0 )                                                  
     return -1;                                                       
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
    rtems_filesystem_freenode( &loc );                                
a00099a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00099a4:	ebfffb7e 	bl	a00087a4 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a00099a8:	eb0029f8 	bl	a0014190 <__errno>                             <== NOT EXECUTED
a00099ac:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00099b0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00099b4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00099b8:	eaffffe0 	b	a0009940 <readlink+0x44>                        <== NOT EXECUTED
                                                                      

a00084fc <readv>: int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd );
a00084fc:	e59f313c 	ldr	r3, [pc, #316]	; a0008640 <readv+0x144>       <== NOT EXECUTED
ssize_t readv(                                                        
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
a0008500:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
a0008504:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
ssize_t readv(                                                        
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
a0008508:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
a000850c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0008510:	2a000045 	bcs	a000862c <readv+0x130>                        <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0008514:	e59f3128 	ldr	r3, [pc, #296]	; a0008644 <readv+0x148>       <== NOT EXECUTED
a0008518:	e3a06038 	mov	r6, #56	; 0x38                                <== NOT EXECUTED
a000851c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0008520:	e0263690 	mla	r6, r0, r6, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
a0008524:	e5963014 	ldr	r3, [r6, #20]                                 <== NOT EXECUTED
a0008528:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a000852c:	0a00003e 	beq	a000862c <readv+0x130>                        <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );             
a0008530:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a0008534:	0a000036 	beq	a0008614 <readv+0x118>                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
a0008538:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000853c:	0a000034 	beq	a0008614 <readv+0x118>                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
a0008540:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0008544:	da000032 	ble	a0008614 <readv+0x118>                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
a0008548:	e3520b01 	cmp	r2, #1024	; 0x400                             <== NOT EXECUTED
a000854c:	ca000030 	bgt	a0008614 <readv+0x118>                        <== NOT EXECUTED
a0008550:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a0008554:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
a0008558:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a000855c:	e3a07001 	mov	r7, #1                                        <== NOT EXECUTED
a0008560:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0008564:	ea000000 	b	a000856c <readv+0x70>                           <== NOT EXECUTED
    if ( iov[v].iov_base == 0 )                                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
a0008568:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
a000856c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
   *  are obvious errors in the iovec.  So this extra loop ensures    
   *  that we do not do anything if there is an argument error.       
   */                                                                 
                                                                      
  all_zeros = true;                                                   
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a0008570:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
a0008574:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008578:	0a000025 	beq	a0008614 <readv+0x118>                        <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
a000857c:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
   *  are obvious errors in the iovec.  So this extra loop ensures    
   *  that we do not do anything if there is an argument error.       
   */                                                                 
                                                                      
  all_zeros = true;                                                   
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a0008580:	e2833008 	add	r3, r3, #8                                    <== NOT EXECUTED
    if ( iov[v].iov_base == 0 )                                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
a0008584:	e081c000 	add	ip, r1, r0                                    <== NOT EXECUTED
    if ( total < old )                                                
a0008588:	e151000c 	cmp	r1, ip                                        <== NOT EXECUTED
a000858c:	ca000020 	bgt	a0008614 <readv+0x118>                        <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
a0008590:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008594:	13a07000 	movne	r7, #0                                      <== NOT EXECUTED
   *  are obvious errors in the iovec.  So this extra loop ensures    
   *  that we do not do anything if there is an argument error.       
   */                                                                 
                                                                      
  all_zeros = true;                                                   
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a0008598:	e1540002 	cmp	r4, r2                                        <== NOT EXECUTED
a000859c:	cafffff1 	bgt	a0008568 <readv+0x6c>                         <== NOT EXECUTED
  /*                                                                  
   *  A readv with all zeros logically has no effect.  Even though    
   *  OpenGroup didn't address this case as they did with writev(),   
   *  we will handle it the same way for symmetry.                    
   */                                                                 
  if ( all_zeros == true ) {                                          
a00085a0:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
    return 0;                                                         
a00085a4:	13a08000 	movne	r8, #0                                      <== NOT EXECUTED
  /*                                                                  
   *  A readv with all zeros logically has no effect.  Even though    
   *  OpenGroup didn't address this case as they did with writev(),   
   *  we will handle it the same way for symmetry.                    
   */                                                                 
  if ( all_zeros == true ) {                                          
a00085a8:	1a00001d 	bne	a0008624 <readv+0x128>                        <== NOT EXECUTED
a00085ac:	e1a08007 	mov	r8, r7                                        <== NOT EXECUTED
a00085b0:	ea00000d 	b	a00085ec <readv+0xf0>                           <== NOT EXECUTED
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
a00085b4:	0a000006 	beq	a00085d4 <readv+0xd8>                         <== NOT EXECUTED
      iop->offset += bytes;                                           
a00085b8:	e286300c 	add	r3, r6, #12                                   <== NOT EXECUTED
a00085bc:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a00085c0:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
a00085c4:	e0a33fc0 	adc	r3, r3, r0, asr #31                           <== NOT EXECUTED
a00085c8:	e586200c 	str	r2, [r6, #12]                                 <== NOT EXECUTED
a00085cc:	e5863010 	str	r3, [r6, #16]                                 <== NOT EXECUTED
      total       += bytes;                                           
a00085d0:	e0888000 	add	r8, r8, r0                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
a00085d4:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a00085d8:	e2855008 	add	r5, r5, #8                                    <== NOT EXECUTED
    if ( bytes > 0 ) {                                                
      iop->offset += bytes;                                           
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
a00085dc:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00085e0:	1a00000f 	bne	a0008624 <readv+0x128>                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a00085e4:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
a00085e8:	da00000d 	ble	a0008624 <readv+0x128>                        <== NOT EXECUTED
    bytes = (*iop->pathinfo.handlers->read_h)(                        
a00085ec:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
a00085f0:	e8950006 	ldm	r5, {r1, r2}                                  <== NOT EXECUTED
a00085f4:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a00085f8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00085fc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
a0008600:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a0008604:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
a0008608:	aaffffe9 	bge	a00085b4 <readv+0xb8>                         <== NOT EXECUTED
      return -1;                                                      
a000860c:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
a0008610:	ea000003 	b	a0008624 <readv+0x128>                          <== NOT EXECUTED
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old )                                                
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0008614:	eb0026e5 	bl	a00121b0 <__errno>                             <== NOT EXECUTED
a0008618:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000861c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0008620:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
a0008624:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0008628:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
a000862c:	eb0026df 	bl	a00121b0 <__errno>                             <== NOT EXECUTED
a0008630:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a0008634:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0008638:	e3e08000 	mvn	r8, #0                                        <== NOT EXECUTED
a000863c:	eafffff8 	b	a0008624 <readv+0x128>                          <== NOT EXECUTED
                                                                      

a00161f0 <realloc>: void *realloc( void *ptr, size_t size ) {
a00161f0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
a00161f4:	e59f3118 	ldr	r3, [pc, #280]	; a0016314 <realloc+0x124>     <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
a00161f8:	e59f5118 	ldr	r5, [pc, #280]	; a0016318 <realloc+0x128>     <== NOT EXECUTED
                                                                      
void *realloc(                                                        
  void *ptr,                                                          
  size_t size                                                         
)                                                                     
{                                                                     
a00161fc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
a0016200:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
a0016204:	e5952010 	ldr	r2, [r5, #16]                                 <== NOT EXECUTED
                                                                      
void *realloc(                                                        
  void *ptr,                                                          
  size_t size                                                         
)                                                                     
{                                                                     
a0016208:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
a001620c:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
a0016210:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
void *realloc(                                                        
  void *ptr,                                                          
  size_t size                                                         
)                                                                     
{                                                                     
a0016214:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
a0016218:	e5852010 	str	r2, [r5, #16]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
a001621c:	0a000020 	beq	a00162a4 <realloc+0xb4>                       <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
a0016220:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0016224:	0a00001a 	beq	a0016294 <realloc+0xa4>                       <== NOT EXECUTED
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
a0016228:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a001622c:	0a00000f 	beq	a0016270 <realloc+0x80>                       <== NOT EXECUTED
    free( ptr );                                                      
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
a0016230:	e59f70e4 	ldr	r7, [pc, #228]	; a001631c <realloc+0x12c>     <== NOT EXECUTED
a0016234:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0016238:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a001623c:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a0016240:	eb000066 	bl	a00163e0 <_Protected_heap_Get_block_size>      <== NOT EXECUTED
a0016244:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
a0016248:	0a00000c 	beq	a0016280 <realloc+0x90>                       <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now resize it.                                                  
   */                                                                 
  if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
a001624c:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a0016250:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0016254:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0016258:	eb000071 	bl	a0016424 <_Protected_heap_Resize_block>        <== NOT EXECUTED
a001625c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0016260:	0a00001a 	beq	a00162d0 <realloc+0xe0>                       <== NOT EXECUTED
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
  free( ptr );                                                        
                                                                      
  return new_area;                                                    
                                                                      
}                                                                     
a0016264:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0016268:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001626c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
    free( ptr );                                                      
a0016270:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0016274:	ebffc03e 	bl	a0006374 <free>                                <== NOT EXECUTED
    return (void *) 0;                                                
a0016278:	e1a04006 	mov	r4, r6                                        <== NOT EXECUTED
a001627c:	eafffff8 	b	a0016264 <realloc+0x74>                         <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
    errno = EINVAL;                                                   
a0016280:	ebffeb96 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a0016284:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0016288:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    return (void *) 0;                                                
a001628c:	e1a04008 	mov	r4, r8                                        <== NOT EXECUTED
a0016290:	eafffff3 	b	a0016264 <realloc+0x74>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
a0016294:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0016298:	ebffc11c 	bl	a0006710 <malloc>                              <== NOT EXECUTED
a001629c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00162a0:	eaffffef 	b	a0016264 <realloc+0x74>                         <== NOT EXECUTED
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_disable_level > 0)                           
a00162a4:	e59f3074 	ldr	r3, [pc, #116]	; a0016320 <realloc+0x130>     <== NOT EXECUTED
a00162a8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00162ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      return (void *) 0;                                              
a00162b0:	13a04000 	movne	r4, #0                                      <== NOT EXECUTED
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_disable_level > 0)                           
a00162b4:	1affffea 	bne	a0016264 <realloc+0x74>                       <== NOT EXECUTED
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
a00162b8:	e59f2064 	ldr	r2, [pc, #100]	; a0016324 <realloc+0x134>     <== NOT EXECUTED
a00162bc:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
a00162c0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      return (void *) 0;                                              
a00162c4:	11a04003 	movne	r4, r3                                      <== NOT EXECUTED
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_disable_level > 0)                           
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
a00162c8:	0affffd4 	beq	a0016220 <realloc+0x30>                       <== NOT EXECUTED
a00162cc:	eaffffe4 	b	a0016264 <realloc+0x74>                         <== NOT EXECUTED
   *  There used to be a free on this error case but it is wrong to   
   *  free the memory per OpenGroup Single UNIX Specification V2      
   *  and the C Standard.                                             
   */                                                                 
                                                                      
  new_area = malloc( size );                                          
a00162d0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00162d4:	ebffc10d 	bl	a0006710 <malloc>                              <== NOT EXECUTED
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
a00162d8:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  if ( !new_area ) {                                                  
a00162dc:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
    return (void *) 0;                                                
a00162e0:	01a04007 	moveq	r4, r7                                      <== NOT EXECUTED
   *  and the C Standard.                                             
   */                                                                 
                                                                      
  new_area = malloc( size );                                          
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
a00162e4:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a00162e8:	e5853004 	str	r3, [r5, #4]                                  <== NOT EXECUTED
                                                                      
  if ( !new_area ) {                                                  
a00162ec:	0affffdc 	beq	a0016264 <realloc+0x74>                       <== NOT EXECUTED
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
a00162f0:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a00162f4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00162f8:	e1560002 	cmp	r6, r2                                        <== NOT EXECUTED
a00162fc:	31a02006 	movcc	r2, r6                                      <== NOT EXECUTED
a0016300:	ebffeda4 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
  free( ptr );                                                        
a0016304:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0016308:	ebffc019 	bl	a0006374 <free>                                <== NOT EXECUTED
                                                                      
  return new_area;                                                    
a001630c:	e1a04007 	mov	r4, r7                                        <== NOT EXECUTED
a0016310:	eaffffd3 	b	a0016264 <realloc+0x74>                         <== NOT EXECUTED
                                                                      

a0007724 <rmdir>: #include <rtems/seterr.h> int rmdir( const char *pathname ) {
a0007724:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a0007728:	e24dd030 	sub	sp, sp, #48	; 0x30                            <== NOT EXECUTED
a000772c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Get the parent node of the node we wish to remove. Find the parent path.
   */                                                                 
                                                                      
  parentpathlen = rtems_filesystem_dirname ( pathname );              
a0007730:	ebfffc1f 	bl	a00067b4 <rtems_filesystem_dirname>            <== NOT EXECUTED
                                                                      
  if ( parentpathlen == 0 )                                           
a0007734:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a0007738:	1a000046 	bne	a0007858 <rmdir+0x134>                        <== NOT EXECUTED
    rtems_filesystem_get_start_loc( pathname, &i, &parentloc );       
a000773c:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a0007740:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0007744:	e28d102c 	add	r1, sp, #44	; 0x2c                            <== NOT EXECUTED
a0007748:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000774c:	eb00004d 	bl	a0007888 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
  const char                       *name;                             
  rtems_filesystem_location_info_t  parentloc;                        
  rtems_filesystem_location_info_t  loc;                              
  int                               i;                                
  int                               result;                           
  bool                              free_parentloc = false;           
a0007750:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
a0007754:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a0007758:	e1a0e004 	mov	lr, r4                                        <== NOT EXECUTED
a000775c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007760:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007764:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  name = pathname + parentpathlen;                                    
a0007768:	e0875005 	add	r5, r7, r5                                    <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000776c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
a0007770:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  name = pathname + parentpathlen;                                    
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a0007774:	eb002c4f 	bl	a00128b8 <strlen>                              <== NOT EXECUTED
a0007778:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000777c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007780:	ebfffc1a 	bl	a00067f0 <rtems_filesystem_prefix_separators>  <== NOT EXECUTED
a0007784:	e0857000 	add	r7, r5, r0                                    <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
a0007788:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000778c:	eb002c49 	bl	a00128b8 <strlen>                              <== NOT EXECUTED
a0007790:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
a0007794:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0007798:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000779c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00077a0:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a00077a4:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a00077a8:	ebfffbcf 	bl	a00066ec <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
a00077ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00077b0:	1a000015 	bne	a000780c <rmdir+0xe8>                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Verify you can remove this node as a directory.                  
   */                                                                 
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
a00077b4:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a00077b8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00077bc:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a00077c0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a00077c4:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a00077c8:	1a000013 	bne	a000781c <rmdir+0xf8>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Use the filesystems rmnod to remove the node.                    
   */                                                                 
                                                                      
  result =  (*loc.handlers->rmnod_h)( &parentloc, &loc );             
a00077cc:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a00077d0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00077d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00077d8:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
a00077dc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a00077e0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a00077e4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00077e8:	ebfffc15 	bl	a0006844 <rtems_filesystem_freenode>           <== NOT EXECUTED
  if ( free_parentloc )                                               
a00077ec:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a00077f0:	1a000002 	bne	a0007800 <rmdir+0xdc>                         <== NOT EXECUTED
    rtems_filesystem_freenode( &parentloc );                          
                                                                      
  return result;                                                      
}                                                                     
a00077f4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00077f8:	e28dd030 	add	sp, sp, #48	; 0x30                            <== NOT EXECUTED
a00077fc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  result =  (*loc.handlers->rmnod_h)( &parentloc, &loc );             
                                                                      
  rtems_filesystem_freenode( &loc );                                  
  if ( free_parentloc )                                               
    rtems_filesystem_freenode( &parentloc );                          
a0007800:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007804:	ebfffc0e 	bl	a0006844 <rtems_filesystem_freenode>           <== NOT EXECUTED
a0007808:	eafffff9 	b	a00077f4 <rmdir+0xd0>                           <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
    if ( free_parentloc )                                             
a000780c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0007810:	1a00000c 	bne	a0007848 <rmdir+0x124>                        <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
    return -1;                                                        
a0007814:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a0007818:	eafffff5 	b	a00077f4 <rmdir+0xd0>                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify you can remove this node as a directory.                  
   */                                                                 
  if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
    rtems_filesystem_freenode( &loc );                                
a000781c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007820:	ebfffc07 	bl	a0006844 <rtems_filesystem_freenode>           <== NOT EXECUTED
    if ( free_parentloc )                                             
a0007824:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0007828:	0a000001 	beq	a0007834 <rmdir+0x110>                        <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
a000782c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007830:	ebfffc03 	bl	a0006844 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
a0007834:	eb002860 	bl	a00119bc <__errno>                             <== NOT EXECUTED
a0007838:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a000783c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a0007840:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a0007844:	eaffffea 	b	a00077f4 <rmdir+0xd0>                           <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
a0007848:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000784c:	ebfffbfc 	bl	a0006844 <rtems_filesystem_freenode>           <== NOT EXECUTED
    return -1;                                                        
a0007850:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a0007854:	eaffffe6 	b	a00077f4 <rmdir+0xd0>                           <== NOT EXECUTED
  parentpathlen = rtems_filesystem_dirname ( pathname );              
                                                                      
  if ( parentpathlen == 0 )                                           
    rtems_filesystem_get_start_loc( pathname, &i, &parentloc );       
  else {                                                              
    result = rtems_filesystem_evaluate_path(pathname, parentpathlen,  
a0007858:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000785c:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a0007860:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0007864:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a0007868:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000786c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0007870:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0007874:	ebfffbb8 	bl	a000675c <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                            RTEMS_LIBIO_PERMS_WRITE,  
                                            &parentloc,               
                                            false );                  
    if ( result != 0 )                                                
a0007878:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000787c:	1affffe4 	bne	a0007814 <rmdir+0xf0>                         <== NOT EXECUTED
      return -1;                                                      
                                                                      
    free_parentloc = true;                                            
a0007880:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
a0007884:	eaffffb2 	b	a0007754 <rmdir+0x30>                           <== NOT EXECUTED
                                                                      

a0006d18 <rtems_assoc_local_by_name>: uint32_t rtems_assoc_local_by_name( const rtems_assoc_t *ap, const char *name ) {
a0006d18:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_name(ap, name);                            
a0006d1c:	eb000091 	bl	a0006f68 <rtems_assoc_ptr_by_name>             <== NOT EXECUTED
  if (nap)                                                            
a0006d20:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return nap->local_value;                                          
a0006d24:	15900004 	ldrne	r0, [r0, #4]                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0006d28:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0010bc4 <rtems_assoc_local_by_remote>: uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
a0010bc4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_remote(ap, remote_value);                  
a0010bc8:	eb000002 	bl	a0010bd8 <rtems_assoc_ptr_by_remote>           <== NOT EXECUTED
  if (nap)                                                            
a0010bcc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return nap->local_value;                                          
a0010bd0:	15900004 	ldrne	r0, [r0, #4]                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a0010bd4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0010b70 <rtems_assoc_local_by_remote_bitfield>: uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) {
a0010b70:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0010b74:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0010b78:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a0010b7c:	e3a05020 	mov	r5, #32                                       <== NOT EXECUTED
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
a0010b80:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0010b84:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
a0010b88:	ea000002 	b	a0010b98 <rtems_assoc_local_by_remote_bitfield+0x28><== NOT EXECUTED
a0010b8c:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
a0010b90:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a0010b94:	0a000008 	beq	a0010bbc <rtems_assoc_local_by_remote_bitfield+0x4c><== NOT EXECUTED
    if (b & remote_value)                                             
a0010b98:	e1140006 	tst	r4, r6                                        <== NOT EXECUTED
a0010b9c:	0afffffa 	beq	a0010b8c <rtems_assoc_local_by_remote_bitfield+0x1c><== NOT EXECUTED
      local_value |= rtems_assoc_local_by_remote(ap, b);              
a0010ba0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0010ba4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0010ba8:	eb000005 	bl	a0010bc4 <rtems_assoc_local_by_remote>         <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0010bac:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
    if (b & remote_value)                                             
      local_value |= rtems_assoc_local_by_remote(ap, b);              
a0010bb0:	e1877000 	orr	r7, r7, r0                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0010bb4:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a0010bb8:	1afffff6 	bne	a0010b98 <rtems_assoc_local_by_remote_bitfield+0x28><== NOT EXECUTED
    if (b & remote_value)                                             
      local_value |= rtems_assoc_local_by_remote(ap, b);              
  }                                                                   
                                                                      
  return local_value;                                                 
}                                                                     
a0010bbc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010bc0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a001646c <rtems_assoc_name_bad>: sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value); #else static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>"; #endif return bad_buffer; }
a001646c:	e59f0000 	ldr	r0, [pc, #0]	; a0016474 <rtems_assoc_name_bad+0x8><== NOT EXECUTED
a0016470:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00139d8 <rtems_assoc_name_by_local>: const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
a00139d8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a00139dc:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
a00139e0:	eb000006 	bl	a0013a00 <rtems_assoc_ptr_by_local>            <== NOT EXECUTED
  if (nap)                                                            
a00139e4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00139e8:	0a000001 	beq	a00139f4 <rtems_assoc_name_by_local+0x1c>     <== NOT EXECUTED
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
}                                                                     
a00139ec:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a00139f0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
a00139f4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a00139f8:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(local_value);                           
a00139fc:	ea000a9a 	b	a001646c <rtems_assoc_name_bad>                 <== NOT EXECUTED
                                                                      

a0006d94 <rtems_assoc_name_by_local_bitfield>: char *rtems_assoc_name_by_local_bitfield( const rtems_assoc_t *ap, uint32_t value, char *buffer ) {
a0006d94:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
a0006d98:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006d9c:	e3a05020 	mov	r5, #32                                       <== NOT EXECUTED
char *rtems_assoc_name_by_local_bitfield(                             
  const rtems_assoc_t *ap,                                            
  uint32_t             value,                                         
  char                *buffer                                         
)                                                                     
{                                                                     
a0006da0:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
a0006da4:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0006da8:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
a0006dac:	e5c23000 	strb	r3, [r2]                                     <== NOT EXECUTED
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0006db0:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
    if (b & value) {                                                  
      if (*buffer)                                                    
        strcat(buffer, " ");                                          
a0006db4:	e1a09005 	mov	r9, r5                                        <== NOT EXECUTED
a0006db8:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
a0006dbc:	ea000008 	b	a0006de4 <rtems_assoc_name_by_local_bitfield+0x50><== NOT EXECUTED
      strcat(buffer, rtems_assoc_name_by_local(ap, b));               
a0006dc0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006dc4:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0006dc8:	eb000012 	bl	a0006e18 <rtems_assoc_name_by_local>           <== NOT EXECUTED
a0006dcc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0006dd0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006dd4:	eb002f4a 	bl	a0012b04 <strcat>                              <== NOT EXECUTED
{                                                                     
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0006dd8:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
a0006ddc:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a0006de0:	0a00000a 	beq	a0006e10 <rtems_assoc_name_by_local_bitfield+0x7c><== NOT EXECUTED
    if (b & value) {                                                  
a0006de4:	e1140007 	tst	r4, r7                                        <== NOT EXECUTED
a0006de8:	0afffffa 	beq	a0006dd8 <rtems_assoc_name_by_local_bitfield+0x44><== NOT EXECUTED
      if (*buffer)                                                    
a0006dec:	e5d63000 	ldrb	r3, [r6]                                     <== NOT EXECUTED
a0006df0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006df4:	0afffff1 	beq	a0006dc0 <rtems_assoc_name_by_local_bitfield+0x2c><== NOT EXECUTED
        strcat(buffer, " ");                                          
a0006df8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006dfc:	eb003047 	bl	a0012f20 <strlen>                              <== NOT EXECUTED
a0006e00:	e0863000 	add	r3, r6, r0                                    <== NOT EXECUTED
a0006e04:	e7c69000 	strb	r9, [r6, r0]                                 <== NOT EXECUTED
a0006e08:	e5c3a001 	strb	sl, [r3, #1]                                 <== NOT EXECUTED
a0006e0c:	eaffffeb 	b	a0006dc0 <rtems_assoc_name_by_local_bitfield+0x2c><== NOT EXECUTED
      strcat(buffer, rtems_assoc_name_by_local(ap, b));               
    }                                                                 
  }                                                                   
                                                                      
  return buffer;                                                      
}                                                                     
a0006e10:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006e14:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

a0006ec4 <rtems_assoc_name_by_remote>: const char *rtems_assoc_name_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
a0006ec4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a0006ec8:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
  nap = rtems_assoc_ptr_by_remote(ap, remote_value);                  
a0006ecc:	eb00004b 	bl	a0007000 <rtems_assoc_ptr_by_remote>           <== NOT EXECUTED
                                                                      
  if (nap)                                                            
a0006ed0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006ed4:	0a000001 	beq	a0006ee0 <rtems_assoc_name_by_remote+0x1c>    <== NOT EXECUTED
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(remote_value);                          
}                                                                     
a0006ed8:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a0006edc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  nap = rtems_assoc_ptr_by_remote(ap, remote_value);                  
                                                                      
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(remote_value);                          
a0006ee0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a0006ee4:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
  nap = rtems_assoc_ptr_by_remote(ap, remote_value);                  
                                                                      
  if (nap)                                                            
    return nap->name;                                                 
                                                                      
  return rtems_assoc_name_bad(remote_value);                          
a0006ee8:	ea00210c 	b	a000f320 <rtems_assoc_name_bad>                 <== NOT EXECUTED
                                                                      

a0006e40 <rtems_assoc_name_by_remote_bitfield>: char *rtems_assoc_name_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t value, char *buffer ) {
a0006e40:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
a0006e44:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006e48:	e3a05020 	mov	r5, #32                                       <== NOT EXECUTED
char *rtems_assoc_name_by_remote_bitfield(                            
  const rtems_assoc_t *ap,                                            
  uint32_t             value,                                         
  char                *buffer                                         
)                                                                     
{                                                                     
a0006e4c:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
a0006e50:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0006e54:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
a0006e58:	e5c23000 	strb	r3, [r2]                                     <== NOT EXECUTED
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0006e5c:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
    if (b & value) {                                                  
      if (*buffer)                                                    
	strcat(buffer, " ");                                                 
a0006e60:	e1a09005 	mov	r9, r5                                        <== NOT EXECUTED
a0006e64:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
a0006e68:	ea000008 	b	a0006e90 <rtems_assoc_name_by_remote_bitfield+0x50><== NOT EXECUTED
      strcat(buffer, rtems_assoc_name_by_remote(ap, b));              
a0006e6c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006e70:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0006e74:	eb000012 	bl	a0006ec4 <rtems_assoc_name_by_remote>          <== NOT EXECUTED
a0006e78:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0006e7c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006e80:	eb002f1f 	bl	a0012b04 <strcat>                              <== NOT EXECUTED
{                                                                     
  uint32_t   b;                                                       
                                                                      
  *buffer = 0;                                                        
                                                                      
  for (b = 1; b; b <<= 1) {                                           
a0006e84:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
a0006e88:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a0006e8c:	0a00000a 	beq	a0006ebc <rtems_assoc_name_by_remote_bitfield+0x7c><== NOT EXECUTED
    if (b & value) {                                                  
a0006e90:	e1140007 	tst	r4, r7                                        <== NOT EXECUTED
a0006e94:	0afffffa 	beq	a0006e84 <rtems_assoc_name_by_remote_bitfield+0x44><== NOT EXECUTED
      if (*buffer)                                                    
a0006e98:	e5d63000 	ldrb	r3, [r6]                                     <== NOT EXECUTED
a0006e9c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006ea0:	0afffff1 	beq	a0006e6c <rtems_assoc_name_by_remote_bitfield+0x2c><== NOT EXECUTED
	strcat(buffer, " ");                                                 
a0006ea4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006ea8:	eb00301c 	bl	a0012f20 <strlen>                              <== NOT EXECUTED
a0006eac:	e0863000 	add	r3, r6, r0                                    <== NOT EXECUTED
a0006eb0:	e7c69000 	strb	r9, [r6, r0]                                 <== NOT EXECUTED
a0006eb4:	e5c3a001 	strb	sl, [r3, #1]                                 <== NOT EXECUTED
a0006eb8:	eaffffeb 	b	a0006e6c <rtems_assoc_name_by_remote_bitfield+0x2c><== NOT EXECUTED
      strcat(buffer, rtems_assoc_name_by_remote(ap, b));              
    }                                                                 
  }                                                                   
                                                                      
  return buffer;                                                      
}                                                                     
a0006ebc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006ec0:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
                                                                      

a0013a00 <rtems_assoc_ptr_by_local>: const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
a0013a00:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0013a04:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0013a08:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
                                                                      
const rtems_assoc_t *rtems_assoc_ptr_by_local(                        
  const rtems_assoc_t *ap,                                            
  uint32_t             local_value                                    
)                                                                     
{                                                                     
a0013a0c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0013a10:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(                        
  const rtems_assoc_t *ap,                                            
  uint32_t             local_value                                    
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0013a14:	01a04000 	moveq	r4, r0                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0013a18:	0a00000a 	beq	a0013a48 <rtems_assoc_ptr_by_local+0x48>      <== NOT EXECUTED
a0013a1c:	e59f1054 	ldr	r1, [pc, #84]	; a0013a78 <rtems_assoc_ptr_by_local+0x78><== NOT EXECUTED
a0013a20:	eb000f7f 	bl	a0017824 <strcmp>                              <== NOT EXECUTED
a0013a24:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(                        
  const rtems_assoc_t *ap,                                            
  uint32_t             local_value                                    
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0013a28:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0013a2c:	1a00000a 	bne	a0013a5c <rtems_assoc_ptr_by_local+0x5c>      <== NOT EXECUTED
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0013a30:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
a0013a34:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
                                                                      
  for ( ; ap->name; ap++)                                             
a0013a38:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0013a3c:	11a02004 	movne	r2, r4                                      <== NOT EXECUTED
a0013a40:	11a04003 	movne	r4, r3                                      <== NOT EXECUTED
a0013a44:	1a000004 	bne	a0013a5c <rtems_assoc_ptr_by_local+0x5c>      <== NOT EXECUTED
    if (ap->local_value == local_value)                               
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
a0013a48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0013a4c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0013a50:	e5b4300c 	ldr	r3, [r4, #12]!                                <== NOT EXECUTED
a0013a54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0013a58:	0a000003 	beq	a0013a6c <rtems_assoc_ptr_by_local+0x6c>      <== NOT EXECUTED
    if (ap->local_value == local_value)                               
a0013a5c:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a0013a60:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a0013a64:	1afffff9 	bne	a0013a50 <rtems_assoc_ptr_by_local+0x50>      <== NOT EXECUTED
a0013a68:	eafffff6 	b	a0013a48 <rtems_assoc_ptr_by_local+0x48>        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0013a6c:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    if (ap->local_value == local_value)                               
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
a0013a70:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0013a74:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0006f68 <rtems_assoc_ptr_by_name>: const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) {
a0006f68:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0006f6c:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
                                                                      
const rtems_assoc_t *rtems_assoc_ptr_by_name(                         
  const rtems_assoc_t *ap,                                            
  const char          *name                                           
)                                                                     
{                                                                     
a0006f70:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0006f74:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0006f78:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(                         
  const rtems_assoc_t *ap,                                            
  const char          *name                                           
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0006f7c:	01a06004 	moveq	r6, r4                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0006f80:	0a000011 	beq	a0006fcc <rtems_assoc_ptr_by_name+0x64>       <== NOT EXECUTED
a0006f84:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006f88:	e59f106c 	ldr	r1, [pc, #108]	; a0006ffc <rtems_assoc_ptr_by_name+0x94><== NOT EXECUTED
a0006f8c:	eb002f07 	bl	a0012bb0 <strcmp>                              <== NOT EXECUTED
a0006f90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(                         
  const rtems_assoc_t *ap,                                            
  const char          *name                                           
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0006f94:	13a08000 	movne	r8, #0                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0006f98:	0a00000d 	beq	a0006fd4 <rtems_assoc_ptr_by_name+0x6c>       <== NOT EXECUTED
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0006f9c:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
a0006fa0:	ea000003 	b	a0006fb4 <rtems_assoc_ptr_by_name+0x4c>         <== NOT EXECUTED
a0006fa4:	e595400c 	ldr	r4, [r5, #12]                                 <== NOT EXECUTED
a0006fa8:	e285500c 	add	r5, r5, #12                                   <== NOT EXECUTED
a0006fac:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0006fb0:	0a00000e 	beq	a0006ff0 <rtems_assoc_ptr_by_name+0x88>       <== NOT EXECUTED
    if (strcmp(ap->name, name) == 0)                                  
a0006fb4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006fb8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0006fbc:	eb002efb 	bl	a0012bb0 <strcmp>                              <== NOT EXECUTED
a0006fc0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0006fc4:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
    if (strcmp(ap->name, name) == 0)                                  
a0006fc8:	1afffff5 	bne	a0006fa4 <rtems_assoc_ptr_by_name+0x3c>       <== NOT EXECUTED
	return ap;                                                           
                                                                      
  return default_ap;                                                  
}                                                                     
a0006fcc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006fd0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0006fd4:	e596400c 	ldr	r4, [r6, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
a0006fd8:	e286300c 	add	r3, r6, #12                                   <== NOT EXECUTED
                                                                      
  for ( ; ap->name; ap++)                                             
a0006fdc:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0006fe0:	11a08006 	movne	r8, r6                                      <== NOT EXECUTED
a0006fe4:	11a06003 	movne	r6, r3                                      <== NOT EXECUTED
a0006fe8:	1affffeb 	bne	a0006f9c <rtems_assoc_ptr_by_name+0x34>       <== NOT EXECUTED
a0006fec:	eafffff6 	b	a0006fcc <rtems_assoc_ptr_by_name+0x64>         <== NOT EXECUTED
a0006ff0:	e1a06008 	mov	r6, r8                                        <== NOT EXECUTED
    if (strcmp(ap->name, name) == 0)                                  
	return ap;                                                           
                                                                      
  return default_ap;                                                  
}                                                                     
a0006ff4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0006ff8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a0010bd8 <rtems_assoc_ptr_by_remote>: const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
a0010bd8:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0010bdc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0010be0:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
                                                                      
const rtems_assoc_t *rtems_assoc_ptr_by_remote(                       
  const rtems_assoc_t *ap,                                            
  uint32_t       remote_value                                         
)                                                                     
{                                                                     
a0010be4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0010be8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_remote(                       
  const rtems_assoc_t *ap,                                            
  uint32_t       remote_value                                         
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0010bec:	01a04000 	moveq	r4, r0                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0010bf0:	0a00000a 	beq	a0010c20 <rtems_assoc_ptr_by_remote+0x48>     <== NOT EXECUTED
a0010bf4:	e59f1054 	ldr	r1, [pc, #84]	; a0010c50 <rtems_assoc_ptr_by_remote+0x78><== NOT EXECUTED
a0010bf8:	eb000446 	bl	a0011d18 <strcmp>                              <== NOT EXECUTED
a0010bfc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_remote(                       
  const rtems_assoc_t *ap,                                            
  uint32_t       remote_value                                         
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
a0010c00:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
                                                                      
  if (rtems_assoc_is_default(ap))                                     
a0010c04:	1a00000a 	bne	a0010c34 <rtems_assoc_ptr_by_remote+0x5c>     <== NOT EXECUTED
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0010c08:	e594200c 	ldr	r2, [r4, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
a0010c0c:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
                                                                      
  for ( ; ap->name; ap++)                                             
a0010c10:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0010c14:	11a02004 	movne	r2, r4                                      <== NOT EXECUTED
a0010c18:	11a04003 	movne	r4, r3                                      <== NOT EXECUTED
a0010c1c:	1a000004 	bne	a0010c34 <rtems_assoc_ptr_by_remote+0x5c>     <== NOT EXECUTED
    if (ap->remote_value == remote_value)                             
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
a0010c20:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010c24:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0010c28:	e5b4300c 	ldr	r3, [r4, #12]!                                <== NOT EXECUTED
a0010c2c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010c30:	0a000003 	beq	a0010c44 <rtems_assoc_ptr_by_remote+0x6c>     <== NOT EXECUTED
    if (ap->remote_value == remote_value)                             
a0010c34:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0010c38:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a0010c3c:	1afffff9 	bne	a0010c28 <rtems_assoc_ptr_by_remote+0x50>     <== NOT EXECUTED
a0010c40:	eafffff6 	b	a0010c20 <rtems_assoc_ptr_by_remote+0x48>       <== NOT EXECUTED
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
a0010c44:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
    if (ap->remote_value == remote_value)                             
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
a0010c48:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010c4c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a00070d0 <rtems_assoc_remote_by_local>: uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
a00070d0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_local(ap, local_value);                    
a00070d4:	ebffff84 	bl	a0006eec <rtems_assoc_ptr_by_local>            <== NOT EXECUTED
  if (nap)                                                            
a00070d8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return nap->remote_value;                                         
a00070dc:	15900008 	ldrne	r0, [r0, #8]                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a00070e0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000707c <rtems_assoc_remote_by_local_bitfield>: uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) {
a000707c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0007080:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0007084:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a0007088:	e3a05020 	mov	r5, #32                                       <== NOT EXECUTED
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
a000708c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
                                                                      
  for (b = 1; b; b <<= 1)                                             
a0007090:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
a0007094:	ea000002 	b	a00070a4 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED
a0007098:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
a000709c:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a00070a0:	0a000008 	beq	a00070c8 <rtems_assoc_remote_by_local_bitfield+0x4c><== NOT EXECUTED
    if (b & local_value)                                              
a00070a4:	e1140006 	tst	r4, r6                                        <== NOT EXECUTED
a00070a8:	0afffffa 	beq	a0007098 <rtems_assoc_remote_by_local_bitfield+0x1c><== NOT EXECUTED
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
a00070ac:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00070b0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a00070b4:	eb000005 	bl	a00070d0 <rtems_assoc_remote_by_local>         <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
                                                                      
  for (b = 1; b; b <<= 1)                                             
a00070b8:	e2555001 	subs	r5, r5, #1                                   <== NOT EXECUTED
    if (b & local_value)                                              
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
a00070bc:	e1877000 	orr	r7, r7, r0                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
                                                                      
  for (b = 1; b; b <<= 1)                                             
a00070c0:	e1a04084 	lsl	r4, r4, #1                                    <== NOT EXECUTED
a00070c4:	1afffff6 	bne	a00070a4 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED
    if (b & local_value)                                              
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
                                                                      
  return remote_value;                                                
}                                                                     
a00070c8:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00070cc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a00070e4 <rtems_assoc_remote_by_name>: uint32_t rtems_assoc_remote_by_name( const rtems_assoc_t *ap, const char *name ) {
a00070e4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *nap;                                           
                                                                      
  nap = rtems_assoc_ptr_by_name(ap, name);                            
a00070e8:	ebffff9e 	bl	a0006f68 <rtems_assoc_ptr_by_name>             <== NOT EXECUTED
  if (nap)                                                            
a00070ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return nap->remote_value;                                         
a00070f0:	15900008 	ldrne	r0, [r0, #8]                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a00070f4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0011884 <rtems_barrier_create>: rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) {
a0011884:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  Barrier_Control         *the_barrier;                               
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0011888:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
  rtems_name           name,                                          
  rtems_attribute      attribute_set,                                 
  uint32_t             maximum_waiters,                               
  rtems_id            *id                                             
)                                                                     
{                                                                     
a001188c:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0011890:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0011894:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  Barrier_Control         *the_barrier;                               
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a0011898:	03a00003 	moveq	r0, #3                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Barrier_Control         *the_barrier;                               
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a001189c:	0a00001e 	beq	a001191c <rtems_barrier_create+0x98>          <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a00118a0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a00118a4:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  CORE_barrier_Attributes  the_attributes;                            
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a00118a8:	0a00001b 	beq	a001191c <rtems_barrier_create+0x98>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
a00118ac:	e3110010 	tst	r1, #16                                       <== NOT EXECUTED
a00118b0:	0a00001b 	beq	a0011924 <rtems_barrier_create+0xa0>          <== NOT EXECUTED
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
a00118b4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    if ( maximum_waiters == 0 )                                       
a00118b8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
a00118bc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
    if ( maximum_waiters == 0 )                                       
a00118c0:	0a00001a 	beq	a0011930 <rtems_barrier_create+0xac>          <== NOT EXECUTED
a00118c4:	e59f3078 	ldr	r3, [pc, #120]	; a0011944 <rtems_barrier_create+0xc0><== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
  } else                                                              
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;          
  the_attributes.maximum_count = maximum_waiters;                     
a00118c8:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a00118cc:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a00118d0:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a00118d4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
 *  This function allocates a barrier control block from              
 *  the inactive chain of free barrier control blocks.                
 */                                                                   
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )       
{                                                                     
  return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
a00118d8:	e59f8068 	ldr	r8, [pc, #104]	; a0011948 <rtems_barrier_create+0xc4><== NOT EXECUTED
a00118dc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a00118e0:	ebffed8d 	bl	a000cf1c <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _Barrier_Allocate();                                  
                                                                      
  if ( !the_barrier ) {                                               
a00118e4:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a00118e8:	0a000012 	beq	a0011938 <rtems_barrier_create+0xb4>          <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_barrier->attribute_set = attribute_set;                         
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
a00118ec:	e2860014 	add	r0, r6, #20                                   <== NOT EXECUTED
a00118f0:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  if ( !the_barrier ) {                                               
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_barrier->attribute_set = attribute_set;                         
a00118f4:	e5865010 	str	r5, [r6, #16]                                 <== NOT EXECUTED
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
a00118f8:	eb00024c 	bl	a0012230 <_CORE_barrier_Initialize>            <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a00118fc:	e5963008 	ldr	r3, [r6, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0011900:	e598201c 	ldr	r2, [r8, #28]                                 <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a0011904:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0011908:	e7826721 	str	r6, [r2, r1, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a001190c:	e586400c 	str	r4, [r6, #12]                                 <== NOT EXECUTED
    &_Barrier_Information,                                            
    &the_barrier->Object,                                             
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_barrier->Object.id;                                       
a0011910:	e5873000 	str	r3, [r7]                                      <== NOT EXECUTED
                                                                      
  _Thread_Enable_dispatch();                                          
a0011914:	ebfff1f2 	bl	a000e0e4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a0011918:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a001191c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0011920:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
    if ( maximum_waiters == 0 )                                       
      return RTEMS_INVALID_NUMBER;                                    
  } else                                                              
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;          
a0011924:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0011928:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a001192c:	eaffffe4 	b	a00118c4 <rtems_barrier_create+0x40>            <== NOT EXECUTED
                                                                      
  /* Initialize core barrier attributes */                            
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {          
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;       
    if ( maximum_waiters == 0 )                                       
      return RTEMS_INVALID_NUMBER;                                    
a0011930:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0011934:	eafffff8 	b	a001191c <rtems_barrier_create+0x98>            <== NOT EXECUTED
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _Barrier_Allocate();                                  
                                                                      
  if ( !the_barrier ) {                                               
    _Thread_Enable_dispatch();                                        
a0011938:	ebfff1e9 	bl	a000e0e4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a001193c:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a0011940:	eafffff5 	b	a001191c <rtems_barrier_create+0x98>            <== NOT EXECUTED
                                                                      

a001194c <rtems_barrier_delete>: */ rtems_status_code rtems_barrier_delete( rtems_id id ) {
a001194c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0011950:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0011954:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Barrier_Control *)                                          
    _Objects_Get( &_Barrier_Information, id, location );              
a0011958:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a001195c:	e59f004c 	ldr	r0, [pc, #76]	; a00119b0 <rtems_barrier_delete+0x64><== NOT EXECUTED
a0011960:	ebffeea0 	bl	a000d3e8 <_Objects_Get>                        <== NOT EXECUTED
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011964:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a0011968:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a001196c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0011970:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011974:	1a00000b 	bne	a00119a8 <rtems_barrier_delete+0x5c>          <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _CORE_barrier_Flush(                                            
a0011978:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a001197c:	e2850014 	add	r0, r5, #20                                   <== NOT EXECUTED
a0011980:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0011984:	ebfff397 	bl	a000e7e8 <_Thread_queue_Flush>                 <== NOT EXECUTED
        &the_barrier->Barrier,                                        
        NULL,                                                         
        CORE_BARRIER_WAS_DELETED                                      
      );                                                              
                                                                      
      _Objects_Close( &_Barrier_Information, &the_barrier->Object );  
a0011988:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a001198c:	e59f001c 	ldr	r0, [pc, #28]	; a00119b0 <rtems_barrier_delete+0x64><== NOT EXECUTED
a0011990:	ebffed86 	bl	a000cfb0 <_Objects_Close>                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Barrier_Free (                             
  Barrier_Control *the_barrier                                        
)                                                                     
{                                                                     
  _Objects_Free( &_Barrier_Information, &the_barrier->Object );       
a0011994:	e59f0014 	ldr	r0, [pc, #20]	; a00119b0 <rtems_barrier_delete+0x64><== NOT EXECUTED
a0011998:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a001199c:	ebffee38 	bl	a000d284 <_Objects_Free>                       <== NOT EXECUTED
                                                                      
      _Barrier_Free( the_barrier );                                   
                                                                      
      _Thread_Enable_dispatch();                                      
a00119a0:	ebfff1cf 	bl	a000e0e4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a00119a4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00119a8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00119ac:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000a9fc <rtems_barrier_ident>: rtems_status_code rtems_barrier_ident( rtems_name name, rtems_id *id ) {
a000a9fc:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000aa00:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a000aa04:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a000aa08:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a000aa0c:	e59f0010 	ldr	r0, [pc, #16]	; a000aa24 <rtems_barrier_ident+0x28><== NOT EXECUTED
a000aa10:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a000aa14:	eb00086b 	bl	a000cbc8 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_LOCAL_NODE,                                        
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a000aa18:	e59f3008 	ldr	r3, [pc, #8]	; a000aa28 <rtems_barrier_ident+0x2c><== NOT EXECUTED
}                                                                     
a000aa1c:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a000aa20:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00119fc <rtems_barrier_release>: rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) {
a00119fc:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !released )                                                    
a0011a00:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_barrier_release(                              
  rtems_id          id,                                               
  uint32_t         *released                                          
)                                                                     
{                                                                     
a0011a04:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0011a08:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !released )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0011a0c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !released )                                                    
a0011a10:	0a00000e 	beq	a0011a50 <rtems_barrier_release+0x54>         <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Barrier_Control *)                                          
    _Objects_Get( &_Barrier_Information, id, location );              
a0011a14:	e59f003c 	ldr	r0, [pc, #60]	; a0011a58 <rtems_barrier_release+0x5c><== NOT EXECUTED
a0011a18:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0011a1c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0011a20:	ebffee70 	bl	a000d3e8 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011a24:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a0011a28:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0011a2c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !released )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011a30:	1a000006 	bne	a0011a50 <rtems_barrier_release+0x54>         <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
a0011a34:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0011a38:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0011a3c:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0011a40:	eb000205 	bl	a001225c <_CORE_barrier_Release>               <== NOT EXECUTED
a0011a44:	e5860000 	str	r0, [r6]                                      <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0011a48:	ebfff1a5 	bl	a000e0e4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0011a4c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0011a50:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0011a54:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0011a5c <rtems_barrier_wait>: rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) {
a0011a5c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0011a60:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0011a64:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0011a68:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0011a6c:	e59f004c 	ldr	r0, [pc, #76]	; a0011ac0 <rtems_barrier_wait+0x64><== NOT EXECUTED
a0011a70:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0011a74:	e28d2004 	add	r2, sp, #4                                    <== NOT EXECUTED
a0011a78:	ebffee5a 	bl	a000d3e8 <_Objects_Get>                        <== NOT EXECUTED
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011a7c:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0011a80:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0011a84:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Barrier_Control   *the_barrier;                                     
  Objects_Locations  location;                                        
                                                                      
  the_barrier = _Barrier_Get( id, &location );                        
  switch ( location ) {                                               
a0011a88:	1a00000a 	bne	a0011ab8 <rtems_barrier_wait+0x5c>            <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _CORE_barrier_Wait(                                             
a0011a8c:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0011a90:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0011a94:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0011a98:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a0011a9c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0011aa0:	eb0001f9 	bl	a001228c <_CORE_barrier_Wait>                  <== NOT EXECUTED
        id,                                                           
        true,                                                         
        timeout,                                                      
        NULL                                                          
      );                                                              
      _Thread_Enable_dispatch();                                      
a0011aa4:	ebfff18e 	bl	a000e0e4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return _Barrier_Translate_core_barrier_return_code(             
                _Thread_Executing->Wait.return_code );                
a0011aa8:	e59f3014 	ldr	r3, [pc, #20]	; a0011ac4 <rtems_barrier_wait+0x68><== NOT EXECUTED
a0011aac:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
        true,                                                         
        timeout,                                                      
        NULL                                                          
      );                                                              
      _Thread_Enable_dispatch();                                      
      return _Barrier_Translate_core_barrier_return_code(             
a0011ab0:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0011ab4:	eb00047e 	bl	a0012cb4 <_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0011ab8:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0011abc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0005d98 <rtems_bsp_cmdline_get>: #include <rtems/bspcmdline.h> extern const char *bsp_boot_cmdline; const char *rtems_bsp_cmdline_get(void) {
a0005d98:	e59f3004 	ldr	r3, [pc, #4]	; a0005da4 <rtems_bsp_cmdline_get+0xc><== NOT EXECUTED
  return bsp_boot_cmdline;                                            
}                                                                     
a0005d9c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a0005da0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0005da8 <rtems_bsp_cmdline_get_param>: const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) {
a0005da8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
a0005dac:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
const char *rtems_bsp_cmdline_get_param(                              
  const char *name,                                                   
  char       *value,                                                  
  size_t      length                                                  
)                                                                     
{                                                                     
a0005db0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    return NULL;                                                      
a0005db4:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
  size_t      length                                                  
)                                                                     
{                                                                     
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
a0005db8:	1a000001 	bne	a0005dc4 <rtems_bsp_cmdline_get_param+0x1c>   <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
a0005dbc:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0005dc0:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
a0005dc4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0005dc8:	1a000001 	bne	a0005dd4 <rtems_bsp_cmdline_get_param+0x2c>   <== NOT EXECUTED
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
a0005dcc:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0005dd0:	eafffff9 	b	a0005dbc <rtems_bsp_cmdline_get_param+0x14>     <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
    return NULL;                                                      
                                                                      
  if ( !length )                                                      
a0005dd4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    return NULL;                                                      
a0005dd8:	01a00002 	moveq	r0, r2                                      <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
    return NULL;                                                      
                                                                      
  if ( !length )                                                      
a0005ddc:	0afffff6 	beq	a0005dbc <rtems_bsp_cmdline_get_param+0x14>   <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  value[0] = '\0';                                                    
a0005de0:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a0005de4:	e5c14000 	strb	r4, [r1]                                     <== NOT EXECUTED
                                                                      
  p = rtems_bsp_cmdline_get_param_raw( name );                        
a0005de8:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
a0005dec:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0005df0:	eb00001e 	bl	a0005e70 <rtems_bsp_cmdline_get_param_raw>     <== NOT EXECUTED
                                                                      
  if ( !p )                                                           
a0005df4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0005df8:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
a0005dfc:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
a0005e00:	0affffed 	beq	a0005dbc <rtems_bsp_cmdline_get_param+0x14>   <== NOT EXECUTED
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
a0005e04:	e5d0c000 	ldrb	ip, [r0]                                     <== NOT EXECUTED
a0005e08:	e15c0004 	cmp	ip, r4                                        <== NOT EXECUTED
a0005e0c:	0affffee 	beq	a0005dcc <rtems_bsp_cmdline_get_param+0x24>   <== NOT EXECUTED
a0005e10:	e2526001 	subs	r6, r2, #1                                   <== NOT EXECUTED
a0005e14:	0affffec 	beq	a0005dcc <rtems_bsp_cmdline_get_param+0x24>   <== NOT EXECUTED
a0005e18:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0005e1c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
      break;                                                          
    value[i++] = *p++;                                                
    value[i] = '\0';                                                  
a0005e20:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
a0005e24:	ea000001 	b	a0005e30 <rtems_bsp_cmdline_get_param+0x88>     <== NOT EXECUTED
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
a0005e28:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a0005e2c:	2affffe6 	bcs	a0005dcc <rtems_bsp_cmdline_get_param+0x24>   <== NOT EXECUTED
    if ( *p == '\"' ) {                                               
a0005e30:	e35c0022 	cmp	ip, #34	; 0x22                                <== NOT EXECUTED
      quotes++;                                                       
a0005e34:	02822001 	addeq	r2, r2, #1                                  <== NOT EXECUTED
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    if ( *p == '\"' ) {                                               
a0005e38:	0a000003 	beq	a0005e4c <rtems_bsp_cmdline_get_param+0xa4>   <== NOT EXECUTED
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
a0005e3c:	e3120001 	tst	r2, #1                                        <== NOT EXECUTED
a0005e40:	1a000001 	bne	a0005e4c <rtems_bsp_cmdline_get_param+0xa4>   <== NOT EXECUTED
a0005e44:	e35c0020 	cmp	ip, #32                                       <== NOT EXECUTED
a0005e48:	0affffdf 	beq	a0005dcc <rtems_bsp_cmdline_get_param+0x24>   <== NOT EXECUTED
      break;                                                          
    value[i++] = *p++;                                                
a0005e4c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0005e50:	e7c1c004 	strb	ip, [r1, r4]                                 <== NOT EXECUTED
    value[i] = '\0';                                                  
a0005e54:	e7c15003 	strb	r5, [r1, r3]                                 <== NOT EXECUTED
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
a0005e58:	e5f0c001 	ldrb	ip, [r0, #1]!                                <== NOT EXECUTED
a0005e5c:	e1a04003 	mov	r4, r3                                        <== NOT EXECUTED
a0005e60:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a0005e64:	1affffef 	bne	a0005e28 <rtems_bsp_cmdline_get_param+0x80>   <== NOT EXECUTED
a0005e68:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a0005e6c:	eaffffd2 	b	a0005dbc <rtems_bsp_cmdline_get_param+0x14>     <== NOT EXECUTED
                                                                      

a0005e70 <rtems_bsp_cmdline_get_param_raw>: const char *name ) { const char *p; if ( !name )
a0005e70:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a0005e74:	1a000001 	bne	a0005e80 <rtems_bsp_cmdline_get_param_raw+0x10><== NOT EXECUTED
    return NULL;                                                      
a0005e78:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  p = strstr(bsp_boot_cmdline, name);                                 
  /* printf( "raw: %p (%s)\n", p, p ); */                             
  return p;                                                           
}                                                                     
a0005e7c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    return NULL;                                                      
                                                                      
  if ( !bsp_boot_cmdline )                                            
a0005e80:	e59f300c 	ldr	r3, [pc, #12]	; a0005e94 <rtems_bsp_cmdline_get_param_raw+0x24><== NOT EXECUTED
a0005e84:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a0005e88:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0005e8c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  p = strstr(bsp_boot_cmdline, name);                                 
a0005e90:	ea00324d 	b	a00127cc <strstr>                               <== NOT EXECUTED
                                                                      

a0005e98 <rtems_bsp_cmdline_get_param_rhs>: const char *rtems_bsp_cmdline_get_param_rhs( const char *name, char *value, size_t length ) {
a0005e98:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0005e9c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0005ea0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  const char *p;                                                      
  const char *rhs;                                                    
  char       *d;                                                      
                                                                      
  p = rtems_bsp_cmdline_get_param( name, value, length );             
a0005ea4:	ebffffbf 	bl	a0005da8 <rtems_bsp_cmdline_get_param>         <== NOT EXECUTED
  if ( !p )                                                           
a0005ea8:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0005eac:	1a000001 	bne	a0005eb8 <rtems_bsp_cmdline_get_param_rhs+0x20><== NOT EXECUTED
    return NULL;                                                      
a0005eb0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005eb4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  rhs = &p[strlen(name)];                                             
a0005eb8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005ebc:	eb0030c6 	bl	a00121dc <strlen>                              <== NOT EXECUTED
  if ( *rhs != '=' )                                                  
a0005ec0:	e7d63000 	ldrb	r3, [r6, r0]                                 <== NOT EXECUTED
                                                                      
  p = rtems_bsp_cmdline_get_param( name, value, length );             
  if ( !p )                                                           
    return NULL;                                                      
                                                                      
  rhs = &p[strlen(name)];                                             
a0005ec4:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
  if ( *rhs != '=' )                                                  
a0005ec8:	e353003d 	cmp	r3, #61	; 0x3d                                <== NOT EXECUTED
a0005ecc:	0a000001 	beq	a0005ed8 <rtems_bsp_cmdline_get_param_rhs+0x40><== NOT EXECUTED
    return NULL;                                                      
a0005ed0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  if ( *(d-1) == '\"' )                                               
    d--;                                                              
  *d = '\0';                                                          
                                                                      
  return value;                                                       
}                                                                     
a0005ed4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  rhs = &p[strlen(name)];                                             
  if ( *rhs != '=' )                                                  
    return NULL;                                                      
                                                                      
  rhs++;                                                              
  if ( *rhs == '\"' )                                                 
a0005ed8:	e5d63001 	ldrb	r3, [r6, #1]                                 <== NOT EXECUTED
                                                                      
  rhs = &p[strlen(name)];                                             
  if ( *rhs != '=' )                                                  
    return NULL;                                                      
                                                                      
  rhs++;                                                              
a0005edc:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
  if ( *rhs == '\"' )                                                 
a0005ee0:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
    rhs++;                                                            
a0005ee4:	05f63001 	ldrbeq	r3, [r6, #1]!                              <== NOT EXECUTED
  for ( d=value ; *rhs ; )                                            
a0005ee8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0005eec:	01a01005 	moveq	r1, r5                                      <== NOT EXECUTED
a0005ef0:	0a000005 	beq	a0005f0c <rtems_bsp_cmdline_get_param_rhs+0x74><== NOT EXECUTED
a0005ef4:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
    *d++ = *rhs++;                                                    
a0005ef8:	e4c23001 	strb	r3, [r2], #1                                 <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  rhs++;                                                              
  if ( *rhs == '\"' )                                                 
    rhs++;                                                            
  for ( d=value ; *rhs ; )                                            
a0005efc:	e5f63001 	ldrb	r3, [r6, #1]!                                <== NOT EXECUTED
    *d++ = *rhs++;                                                    
a0005f00:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
    return NULL;                                                      
                                                                      
  rhs++;                                                              
  if ( *rhs == '\"' )                                                 
    rhs++;                                                            
  for ( d=value ; *rhs ; )                                            
a0005f04:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0005f08:	1afffffa 	bne	a0005ef8 <rtems_bsp_cmdline_get_param_rhs+0x60><== NOT EXECUTED
    *d++ = *rhs++;                                                    
  if ( *(d-1) == '\"' )                                               
a0005f0c:	e5513001 	ldrb	r3, [r1, #-1]                                <== NOT EXECUTED
    d--;                                                              
  *d = '\0';                                                          
                                                                      
  return value;                                                       
a0005f10:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
  rhs++;                                                              
  if ( *rhs == '\"' )                                                 
    rhs++;                                                            
  for ( d=value ; *rhs ; )                                            
    *d++ = *rhs++;                                                    
  if ( *(d-1) == '\"' )                                               
a0005f14:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a0005f18:	02411001 	subeq	r1, r1, #1                                  <== NOT EXECUTED
    d--;                                                              
  *d = '\0';                                                          
a0005f1c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0005f20:	e5c13000 	strb	r3, [r1]                                     <== NOT EXECUTED
                                                                      
  return value;                                                       
a0005f24:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000b8b0 <rtems_build_id>: uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
a000b8b0:	e1a00c00 	lsl	r0, r0, #24                                   <== NOT EXECUTED
a000b8b4:	e1800d81 	orr	r0, r0, r1, lsl #27                           <== NOT EXECUTED
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
a000b8b8:	e1800003 	orr	r0, r0, r3                                    <== NOT EXECUTED
  uint32_t node,                                                      
  uint32_t index                                                      
)                                                                     
{                                                                     
  return _Objects_Build_id( api, class, node, index );                
}                                                                     
a000b8bc:	e1800802 	orr	r0, r0, r2, lsl #16                           <== NOT EXECUTED
a000b8c0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b8c4 <rtems_build_name>: char C1, char C2, char C3, char C4 ) {
a000b8c4:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a000b8c8:	e1a02402 	lsl	r2, r2, #8                                    <== NOT EXECUTED
  return _Objects_Build_name( C1, C2, C3, C4 );                       
a000b8cc:	e20118ff 	and	r1, r1, #16711680	; 0xff0000                  <== NOT EXECUTED
a000b8d0:	e1811c00 	orr	r1, r1, r0, lsl #24                           <== NOT EXECUTED
a000b8d4:	e2022cff 	and	r2, r2, #65280	; 0xff00                       <== NOT EXECUTED
  char C1,                                                            
  char C2,                                                            
  char C3,                                                            
  char C4                                                             
)                                                                     
{                                                                     
a000b8d8:	e20330ff 	and	r3, r3, #255	; 0xff                           <== NOT EXECUTED
  return _Objects_Build_name( C1, C2, C3, C4 );                       
a000b8dc:	e1811002 	orr	r1, r1, r2                                    <== NOT EXECUTED
}                                                                     
a000b8e0:	e1810003 	orr	r0, r1, r3                                    <== NOT EXECUTED
a000b8e4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a93c <rtems_chain_append_with_notification>: rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) {
a000a93c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000a940:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a000a944:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(        
  rtems_chain_control *chain,                                         
  rtems_chain_node *node                                              
)                                                                     
{                                                                     
  return _Chain_Append_with_empty_check( chain, node );               
a000a948:	eb000137 	bl	a000ae2c <_Chain_Append_with_empty_check>      <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_append_with_empty_check( chain, node );
                                                                      
  if ( was_empty ) {                                                  
a000a94c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a950:	1a000000 	bne	a000a958 <rtems_chain_append_with_notification+0x1c><== NOT EXECUTED
    sc = rtems_event_send( task, events );                            
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000a954:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_append_with_empty_check( chain, node );
                                                                      
  if ( was_empty ) {                                                  
    sc = rtems_event_send( task, events );                            
a000a958:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a95c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000a960:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_append_with_empty_check( chain, node );
                                                                      
  if ( was_empty ) {                                                  
    sc = rtems_event_send( task, events );                            
a000a964:	eafffd86 	b	a0009f84 <rtems_event_send>                     <== NOT EXECUTED
                                                                      

a000a968 <rtems_chain_get_with_notification>: rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) {
a000a968:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000a96c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(           
  rtems_chain_control *chain,                                         
  rtems_chain_node **node                                             
)                                                                     
{                                                                     
  return _Chain_Get_with_empty_check( chain, node );                  
a000a970:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a000a974:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a000a978:	eb00014e 	bl	a000aeb8 <_Chain_Get_with_empty_check>         <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool is_empty = rtems_chain_get_with_empty_check( chain, node );    
                                                                      
  if ( is_empty ) {                                                   
a000a97c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a980:	1a000000 	bne	a000a988 <rtems_chain_get_with_notification+0x20><== NOT EXECUTED
    sc = rtems_event_send( task, events );                            
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000a984:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool is_empty = rtems_chain_get_with_empty_check( chain, node );    
                                                                      
  if ( is_empty ) {                                                   
    sc = rtems_event_send( task, events );                            
a000a988:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a98c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000a990:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool is_empty = rtems_chain_get_with_empty_check( chain, node );    
                                                                      
  if ( is_empty ) {                                                   
    sc = rtems_event_send( task, events );                            
a000a994:	eafffd7a 	b	a0009f84 <rtems_event_send>                     <== NOT EXECUTED
                                                                      

a000a998 <rtems_chain_get_with_wait>: rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) {
a000a998:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a000a99c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000a9a0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a000a9a4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a000a9a8:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a000a9ac:	e1a0a003 	mov	sl, r3                                        <== NOT EXECUTED
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
a000a9b0:	e1a0800d 	mov	r8, sp                                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
a000a9b4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a9b8:	eb000153 	bl	a000af0c <_Chain_Get>                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
a000a9bc:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
a000a9c0:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000a9c4:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
a000a9c8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000a9cc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
a000a9d0:	1a000005 	bne	a000a9ec <rtems_chain_get_with_wait+0x54>     <== NOT EXECUTED
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
a000a9d4:	ebfffd0d 	bl	a0009e10 <rtems_event_receive>                 <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
a000a9d8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a9dc:	0afffff4 	beq	a000a9b4 <rtems_chain_get_with_wait+0x1c>     <== NOT EXECUTED
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
a000a9e0:	e58a4000 	str	r4, [sl]                                      <== NOT EXECUTED
                                                                      
  return sc;                                                          
}                                                                     
a000a9e4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000a9e8:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
a000a9ec:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a9f0:	eafffffa 	b	a000a9e0 <rtems_chain_get_with_wait+0x48>       <== NOT EXECUTED
                                                                      

a000a9f4 <rtems_chain_prepend_with_notification>: rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) {
a000a9f4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000a9f8:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a000a9fc:	e1a05003 	mov	r5, r3                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(       
  rtems_chain_control *chain,                                         
  rtems_chain_node *node                                              
)                                                                     
{                                                                     
  return _Chain_Prepend_with_empty_check( chain, node );              
a000aa00:	eb000158 	bl	a000af68 <_Chain_Prepend_with_empty_check>     <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
                                                                      
  if (was_empty) {                                                    
a000aa04:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000aa08:	1a000000 	bne	a000aa10 <rtems_chain_prepend_with_notification+0x1c><== NOT EXECUTED
    sc = rtems_event_send( task, events );                            
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000aa0c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
                                                                      
  if (was_empty) {                                                    
    sc = rtems_event_send( task, events );                            
a000aa10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000aa14:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
a000aa18:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
                                                                      
  if (was_empty) {                                                    
    sc = rtems_event_send( task, events );                            
a000aa1c:	eafffd58 	b	a0009f84 <rtems_event_send>                     <== NOT EXECUTED
                                                                      

a0016dc8 <rtems_clock_get>: rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) {
a0016dc8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if ( !time_buffer )                                                 
a0016dcc:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
a0016dd0:	0a000012 	beq	a0016e20 <rtems_clock_get+0x58>               <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( option == RTEMS_CLOCK_GET_TOD )                                
a0016dd4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0016dd8:	0a00000d 	beq	a0016e14 <rtems_clock_get+0x4c>               <== NOT EXECUTED
    return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );   
                                                                      
  if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )                
a0016ddc:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0016de0:	0a000011 	beq	a0016e2c <rtems_clock_get+0x64>               <== NOT EXECUTED
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {                 
a0016de4:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a0016de8:	0a000012 	beq	a0016e38 <rtems_clock_get+0x70>               <== NOT EXECUTED
                                                                      
    *interval = rtems_clock_get_ticks_since_boot();                   
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {                 
a0016dec:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
a0016df0:	0a000014 	beq	a0016e48 <rtems_clock_get+0x80>               <== NOT EXECUTED
                                                                      
    *interval = rtems_clock_get_ticks_per_second();                   
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
a0016df4:	e3500004 	cmp	r0, #4                                        <== NOT EXECUTED
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
a0016df8:	13a0300a 	movne	r3, #10                                     <== NOT EXECUTED
                                                                      
    *interval = rtems_clock_get_ticks_per_second();                   
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
a0016dfc:	0a000001 	beq	a0016e08 <rtems_clock_get+0x40>               <== NOT EXECUTED
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
a0016e00:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0016e04:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
    *interval = rtems_clock_get_ticks_per_second();                   
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
a0016e08:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
a0016e0c:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
    *interval = rtems_clock_get_ticks_per_second();                   
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
a0016e10:	ea000060 	b	a0016f98 <rtems_clock_get_tod_timeval>          <== NOT EXECUTED
{                                                                     
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( option == RTEMS_CLOCK_GET_TOD )                                
    return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );   
a0016e14:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
a0016e18:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
{                                                                     
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( option == RTEMS_CLOCK_GET_TOD )                                
    return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );   
a0016e1c:	ea000027 	b	a0016ec0 <rtems_clock_get_tod>                  <== NOT EXECUTED
  rtems_clock_get_options  option,                                    
  void                    *time_buffer                                
)                                                                     
{                                                                     
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
a0016e20:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
a0016e24:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0016e28:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  if ( option == RTEMS_CLOCK_GET_TOD )                                
    return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );   
                                                                      
  if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )                
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
a0016e2c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
  if ( option == RTEMS_CLOCK_GET_TIME_VALUE )                         
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
                                                                      
  return RTEMS_INVALID_NUMBER;                                        
                                                                      
}                                                                     
a0016e30:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
                                                                      
  if ( option == RTEMS_CLOCK_GET_TOD )                                
    return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );   
                                                                      
  if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )                
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
a0016e34:	ea000007 	b	a0016e58 <rtems_clock_get_seconds_since_epoch>  <== NOT EXECUTED
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {                 
    rtems_interval *interval = (rtems_interval *)time_buffer;         
                                                                      
    *interval = rtems_clock_get_ticks_since_boot();                   
a0016e38:	eb00001c 	bl	a0016eb0 <rtems_clock_get_ticks_since_boot>    <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0016e3c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {                 
    rtems_interval *interval = (rtems_interval *)time_buffer;         
                                                                      
    *interval = rtems_clock_get_ticks_since_boot();                   
a0016e40:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0016e44:	eaffffed 	b	a0016e00 <rtems_clock_get+0x38>                 <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {                 
    rtems_interval *interval = (rtems_interval *)time_buffer;         
                                                                      
    *interval = rtems_clock_get_ticks_per_second();                   
a0016e48:	eb000010 	bl	a0016e90 <rtems_clock_get_ticks_per_second>    <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0016e4c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {                 
    rtems_interval *interval = (rtems_interval *)time_buffer;         
                                                                      
    *interval = rtems_clock_get_ticks_per_second();                   
a0016e50:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0016e54:	eaffffe9 	b	a0016e00 <rtems_clock_get+0x38>                 <== NOT EXECUTED
                                                                      

a000a830 <rtems_clock_get_seconds_since_epoch>: rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval )
a000a830:	e2502000 	subs	r2, r0, #0                                   <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a000a834:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
                                                                      
rtems_status_code rtems_clock_get_seconds_since_epoch(                
  rtems_interval *the_interval                                        
)                                                                     
{                                                                     
  if ( !the_interval )                                                
a000a838:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a000a83c:	e59f301c 	ldr	r3, [pc, #28]	; a000a860 <rtems_clock_get_seconds_since_epoch+0x30><== NOT EXECUTED
a000a840:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
a000a844:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  *the_interval = _TOD_Seconds_since_epoch();                         
a000a848:	159f3014 	ldrne	r3, [pc, #20]	; a000a864 <rtems_clock_get_seconds_since_epoch+0x34><== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a000a84c:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
{                                                                     
  if ( !the_interval )                                                
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
a000a850:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
                                                                      
  *the_interval = _TOD_Seconds_since_epoch();                         
a000a854:	15933000 	ldrne	r3, [r3]                                    <== NOT EXECUTED
a000a858:	15823000 	strne	r3, [r2]                                    <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000a85c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00093cc <rtems_clock_get_ticks_per_second>: #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> rtems_interval rtems_clock_get_ticks_per_second(void) { return TOD_MICROSECONDS_PER_SECOND /
a00093cc:	e59f3014 	ldr	r3, [pc, #20]	; a00093e8 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED
a00093d0:	e3a0093d 	mov	r0, #999424	; 0xf4000                         <== NOT EXECUTED
#include <rtems/score/thread.h>                                       
#include <rtems/score/tod.h>                                          
#include <rtems/score/watchdog.h>                                     
                                                                      
rtems_interval rtems_clock_get_ticks_per_second(void)                 
{                                                                     
a00093d4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  return TOD_MICROSECONDS_PER_SECOND /                                
a00093d8:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
a00093dc:	e2800d09 	add	r0, r0, #576	; 0x240                          <== NOT EXECUTED
a00093e0:	eb002d01 	bl	a00147ec <__aeabi_uidiv>                       <== NOT EXECUTED
    rtems_configuration_get_microseconds_per_tick();                  
}                                                                     
a00093e4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00093ec <rtems_clock_get_ticks_since_boot>: #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> rtems_interval rtems_clock_get_ticks_since_boot(void) { return _Watchdog_Ticks_since_boot;
a00093ec:	e59f3004 	ldr	r3, [pc, #4]	; a00093f8 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED
a00093f0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
}                                                                     
a00093f4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a898 <rtems_clock_get_tod>: #include <rtems/score/watchdog.h> rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) {
a000a898:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  rtems_time_of_day *tmbuf = time_buffer;                             
  struct tm time;                                                     
  struct timeval now;                                                 
                                                                      
  if ( !time_buffer )                                                 
a000a89c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
#include <rtems/score/watchdog.h>                                     
                                                                      
rtems_status_code rtems_clock_get_tod(                                
  rtems_time_of_day  *time_buffer                                     
)                                                                     
{                                                                     
a000a8a0:	e24dd034 	sub	sp, sp, #52	; 0x34                            <== NOT EXECUTED
  rtems_time_of_day *tmbuf = time_buffer;                             
  struct tm time;                                                     
  struct timeval now;                                                 
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
a000a8a4:	03a03009 	moveq	r3, #9                                      <== NOT EXECUTED
{                                                                     
  rtems_time_of_day *tmbuf = time_buffer;                             
  struct tm time;                                                     
  struct timeval now;                                                 
                                                                      
  if ( !time_buffer )                                                 
a000a8a8:	0a00002a 	beq	a000a958 <rtems_clock_get_tod+0xc0>           <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a000a8ac:	e59f30b0 	ldr	r3, [pc, #176]	; a000a964 <rtems_clock_get_tod+0xcc><== NOT EXECUTED
a000a8b0:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
a000a8b4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a000a8b8:	03a0300b 	moveq	r3, #11                                     <== NOT EXECUTED
  struct timeval now;                                                 
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a000a8bc:	0a000025 	beq	a000a958 <rtems_clock_get_tod+0xc0>           <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000a8c0:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a000a8c4:	e3853080 	orr	r3, r5, #128	; 0x80                           <== NOT EXECUTED
a000a8c8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  ISR_Level       level;                                              
  struct timespec now;                                                
  suseconds_t     useconds;                                           
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
a000a8cc:	e28d0024 	add	r0, sp, #36	; 0x24                            <== NOT EXECUTED
a000a8d0:	eb000657 	bl	a000c234 <_TOD_Get>                            <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000a8d4:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a000a8d8:	e59f3088 	ldr	r3, [pc, #136]	; a000a968 <rtems_clock_get_tod+0xd0><== NOT EXECUTED
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
a000a8dc:	e59d2028 	ldr	r2, [sp, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  /* Obtain the current time */                                       
  _TOD_Get_timeval( &now );                                           
                                                                      
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
a000a8e0:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a000a8e4:	e0c30392 	smull	r0, r3, r2, r3                              <== NOT EXECUTED
a000a8e8:	e1a02fc2 	asr	r2, r2, #31                                   <== NOT EXECUTED
a000a8ec:	e0623343 	rsb	r3, r2, r3, asr #6                            <== NOT EXECUTED
                                                                      
  time->tv_sec  = now.tv_sec;                                         
a000a8f0:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000a8f4:	e28d002c 	add	r0, sp, #44	; 0x2c                            <== NOT EXECUTED
  time->tv_usec = useconds;                                           
a000a8f8:	e58d3030 	str	r3, [sp, #48]	; 0x30                          <== NOT EXECUTED
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
                                                                      
  time->tv_sec  = now.tv_sec;                                         
a000a8fc:	e58d202c 	str	r2, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a000a900:	eb002347 	bl	a0013624 <gmtime_r>                            <== NOT EXECUTED
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
  tmbuf->month  = time.tm_mon + 1;                                    
a000a904:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
                                                                      
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
a000a908:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;                                    
  tmbuf->day    = time.tm_mday;                                       
  tmbuf->hour   = time.tm_hour;                                       
  tmbuf->minute = time.tm_min;                                        
  tmbuf->second = time.tm_sec;                                        
  tmbuf->ticks  = now.tv_usec /                                       
a000a90c:	e59d0030 	ldr	r0, [sp, #48]	; 0x30                          <== NOT EXECUTED
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
  tmbuf->month  = time.tm_mon + 1;                                    
a000a910:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000a914:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
  tmbuf->day    = time.tm_mday;                                       
a000a918:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
                                                                      
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
a000a91c:	e2822e76 	add	r2, r2, #1888	; 0x760                         <== NOT EXECUTED
a000a920:	e282200c 	add	r2, r2, #12                                   <== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;                                    
  tmbuf->day    = time.tm_mday;                                       
a000a924:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  tmbuf->hour   = time.tm_hour;                                       
a000a928:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  /* Split it into a closer format */                                 
  gmtime_r( &now.tv_sec, &time );                                     
                                                                      
  /* Now adjust it to the RTEMS format */                             
  tmbuf->year   = time.tm_year + 1900;                                
a000a92c:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;                                    
  tmbuf->day    = time.tm_mday;                                       
  tmbuf->hour   = time.tm_hour;                                       
a000a930:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
  tmbuf->minute = time.tm_min;                                        
a000a934:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a000a938:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
  tmbuf->second = time.tm_sec;                                        
a000a93c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000a940:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
  tmbuf->ticks  = now.tv_usec /                                       
a000a944:	e59f3020 	ldr	r3, [pc, #32]	; a000a96c <rtems_clock_get_tod+0xd4><== NOT EXECUTED
a000a948:	e593100c 	ldr	r1, [r3, #12]                                 <== NOT EXECUTED
a000a94c:	eb0046ef 	bl	a001c510 <__aeabi_uidiv>                       <== NOT EXECUTED
    rtems_configuration_get_microseconds_per_tick();                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a000a950:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;                                    
  tmbuf->day    = time.tm_mday;                                       
  tmbuf->hour   = time.tm_hour;                                       
  tmbuf->minute = time.tm_min;                                        
  tmbuf->second = time.tm_sec;                                        
  tmbuf->ticks  = now.tv_usec /                                       
a000a954:	e5840018 	str	r0, [r4, #24]                                 <== NOT EXECUTED
    rtems_configuration_get_microseconds_per_tick();                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000a958:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000a95c:	e28dd034 	add	sp, sp, #52	; 0x34                            <== NOT EXECUTED
a000a960:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0016f98 <rtems_clock_get_tod_timeval>: #include <rtems/score/watchdog.h> rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) {
a0016f98:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if ( !time )                                                        
a0016f9c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
#include <rtems/score/watchdog.h>                                     
                                                                      
rtems_status_code rtems_clock_get_tod_timeval(                        
  struct timeval  *time                                               
)                                                                     
{                                                                     
a0016fa0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  if ( !time )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a0016fa4:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
                                                                      
rtems_status_code rtems_clock_get_tod_timeval(                        
  struct timeval  *time                                               
)                                                                     
{                                                                     
  if ( !time )                                                        
a0016fa8:	0a000012 	beq	a0016ff8 <rtems_clock_get_tod_timeval+0x60>   <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a0016fac:	e59f304c 	ldr	r3, [pc, #76]	; a0017000 <rtems_clock_get_tod_timeval+0x68><== NOT EXECUTED
a0016fb0:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
a0016fb4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a0016fb8:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( !time )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a0016fbc:	0a00000d 	beq	a0016ff8 <rtems_clock_get_tod_timeval+0x60>   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0016fc0:	e10f5000 	mrs	r5, CPSR                                      <== NOT EXECUTED
a0016fc4:	e3853080 	orr	r3, r5, #128	; 0x80                           <== NOT EXECUTED
a0016fc8:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  ISR_Level       level;                                              
  struct timespec now;                                                
  suseconds_t     useconds;                                           
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
a0016fcc:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0016fd0:	eb0011c8 	bl	a001b6f8 <_TOD_Get>                            <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0016fd4:	e129f005 	msr	CPSR_fc, r5                                   <== NOT EXECUTED
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a0016fd8:	e59f2024 	ldr	r2, [pc, #36]	; a0017004 <rtems_clock_get_tod_timeval+0x6c><== NOT EXECUTED
                                                                      
  _ISR_Disable(level);                                                
    _TOD_Get( &now );                                                 
  _ISR_Enable(level);                                                 
                                                                      
  useconds = (suseconds_t)now.tv_nsec;                                
a0016fdc:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  _TOD_Get_timeval( time );                                           
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0016fe0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;           
a0016fe4:	e0c21293 	smull	r1, r2, r3, r2                              <== NOT EXECUTED
a0016fe8:	e1a03fc3 	asr	r3, r3, #31                                   <== NOT EXECUTED
a0016fec:	e0633342 	rsb	r3, r3, r2, asr #6                            <== NOT EXECUTED
                                                                      
  time->tv_sec  = now.tv_sec;                                         
a0016ff0:	e59d2000 	ldr	r2, [sp]                                      <== NOT EXECUTED
  time->tv_usec = useconds;                                           
a0016ff4:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
}                                                                     
a0016ff8:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0016ffc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0009624 <rtems_clock_get_uptime>: */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime )
a0009624:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
 *    error code       - if unsuccessful                              
 */                                                                   
rtems_status_code rtems_clock_get_uptime(                             
  struct timespec *uptime                                             
)                                                                     
{                                                                     
a0009628:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  if ( !uptime )                                                      
a000962c:	0a000002 	beq	a000963c <rtems_clock_get_uptime+0x18>        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _TOD_Get_uptime_as_timespec( uptime );                              
a0009630:	eb00058a 	bl	a000ac60 <_TOD_Get_uptime_as_timespec>         <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a0009634:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0009638:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
rtems_status_code rtems_clock_get_uptime(                             
  struct timespec *uptime                                             
)                                                                     
{                                                                     
  if ( !uptime )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a000963c:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
                                                                      
  _TOD_Get_uptime_as_timespec( uptime );                              
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009640:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000a98c <rtems_clock_set>: */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) {
a000a98c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  struct timespec  newtime;                                           
                                                                      
  if ( !time_buffer )                                                 
a000a990:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_clock_set(                                    
  rtems_time_of_day *time_buffer                                      
)                                                                     
{                                                                     
a000a994:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  struct timespec  newtime;                                           
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
a000a998:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  rtems_time_of_day *time_buffer                                      
)                                                                     
{                                                                     
  struct timespec  newtime;                                           
                                                                      
  if ( !time_buffer )                                                 
a000a99c:	0a000015 	beq	a000a9f8 <rtems_clock_set+0x6c>               <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( _TOD_Validate( time_buffer ) ) {                               
a000a9a0:	eb000054 	bl	a000aaf8 <_TOD_Validate>                       <== NOT EXECUTED
a000a9a4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    _Thread_Disable_dispatch();                                       
      _TOD_Set( &newtime );                                           
    _Thread_Enable_dispatch();                                        
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
  return RTEMS_INVALID_CLOCK;                                         
a000a9a8:	03a00014 	moveq	r0, #20                                     <== NOT EXECUTED
  struct timespec  newtime;                                           
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( _TOD_Validate( time_buffer ) ) {                               
a000a9ac:	0a000011 	beq	a000a9f8 <rtems_clock_set+0x6c>               <== NOT EXECUTED
    newtime.tv_sec = _TOD_To_seconds( time_buffer );                  
a000a9b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a9b4:	eb000028 	bl	a000aa5c <_TOD_To_seconds>                     <== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *                            
a000a9b8:	e59f2040 	ldr	r2, [pc, #64]	; a000aa00 <rtems_clock_set+0x74><== NOT EXECUTED
a000a9bc:	e5941018 	ldr	r1, [r4, #24]                                 <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000a9c0:	e59f303c 	ldr	r3, [pc, #60]	; a000aa04 <rtems_clock_set+0x78><== NOT EXECUTED
a000a9c4:	e592c00c 	ldr	ip, [r2, #12]                                 <== NOT EXECUTED
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( _TOD_Validate( time_buffer ) ) {                               
    newtime.tv_sec = _TOD_To_seconds( time_buffer );                  
a000a9c8:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
a000a9cc:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *                            
a000a9d0:	e001019c 	mul	r1, ip, r1                                    <== NOT EXECUTED
a000a9d4:	e3a0cffa 	mov	ip, #1000	; 0x3e8                             <== NOT EXECUTED
a000a9d8:	e001019c 	mul	r1, ip, r1                                    <== NOT EXECUTED
a000a9dc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a9e0:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
a000a9e4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
      rtems_configuration_get_nanoseconds_per_tick();                 
                                                                      
    _Thread_Disable_dispatch();                                       
      _TOD_Set( &newtime );                                           
a000a9e8:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a000a9ec:	eb000652 	bl	a000c33c <_TOD_Set>                            <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
a000a9f0:	eb000c6e 	bl	a000dbb0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a000a9f4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  return RTEMS_INVALID_CLOCK;                                         
}                                                                     
a000a9f8:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000a9fc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a00093fc <rtems_clock_set_nanoseconds_extension>: */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { if ( !routine )
a00093fc:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _Watchdog_Nanoseconds_since_tick_handler = routine;                 
a0009400:	159f200c 	ldrne	r2, [pc, #12]	; a0009414 <rtems_clock_set_nanoseconds_extension+0x18><== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a0009404:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
rtems_status_code rtems_clock_set_nanoseconds_extension(              
  rtems_nanoseconds_extension_routine routine                         
)                                                                     
{                                                                     
  if ( !routine )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
a0009408:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
                                                                      
  _Watchdog_Nanoseconds_since_tick_handler = routine;                 
a000940c:	15823000 	strne	r3, [r2]                                    <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009410:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0009418 <rtems_clock_tick>: * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) {
a0009418:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  _TOD_Tickle_ticks();                                                
a000941c:	eb000529 	bl	a000a8c8 <_TOD_Tickle_ticks>                   <== NOT EXECUTED
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )              
{                                                                     
                                                                      
  _Watchdog_Tickle( &_Watchdog_Ticks_chain );                         
a0009420:	e59f0038 	ldr	r0, [pc, #56]	; a0009460 <rtems_clock_tick+0x48><== NOT EXECUTED
a0009424:	eb000efd 	bl	a000d020 <_Watchdog_Tickle>                    <== NOT EXECUTED
                                                                      
  _Watchdog_Tickle_ticks();                                           
                                                                      
  _Thread_Tickle_timeslice();                                         
a0009428:	eb000d6c 	bl	a000c9e0 <_Thread_Tickle_timeslice>            <== NOT EXECUTED
 *  otherwise.                                                        
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) 
{                                                                     
  return ( _Thread_Dispatch_necessary );                              
a000942c:	e59f3030 	ldr	r3, [pc, #48]	; a0009464 <rtems_clock_tick+0x4c><== NOT EXECUTED
a0009430:	e5d33010 	ldrb	r3, [r3, #16]                                <== NOT EXECUTED
                                                                      
  if ( _Thread_Is_context_switch_necessary() &&                       
a0009434:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0009438:	0a000003 	beq	a000944c <rtems_clock_tick+0x34>              <== NOT EXECUTED
 *  otherwise.                                                        
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )      
{                                                                     
  return ( _Thread_Dispatch_disable_level == 0 );                     
a000943c:	e59f3024 	ldr	r3, [pc, #36]	; a0009468 <rtems_clock_tick+0x50><== NOT EXECUTED
a0009440:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0009444:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0009448:	0a000001 	beq	a0009454 <rtems_clock_tick+0x3c>              <== NOT EXECUTED
       _Thread_Is_dispatching_enabled() )                             
    _Thread_Dispatch();                                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000944c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0009450:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  _Thread_Tickle_timeslice();                                         
                                                                      
  if ( _Thread_Is_context_switch_necessary() &&                       
       _Thread_Is_dispatching_enabled() )                             
    _Thread_Dispatch();                                               
a0009454:	eb000a87 	bl	a000be78 <_Thread_Dispatch>                    <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009458:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000945c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0006b54 <rtems_cpu_usage_report>: void rtems_cpu_usage_report( void ) { rtems_cpu_usage_report_with_plugin( NULL, printk_plugin );
a0006b54:	e59f1004 	ldr	r1, [pc, #4]	; a0006b60 <rtems_cpu_usage_report+0xc><== NOT EXECUTED
a0006b58:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006b5c:	eaffff80 	b	a0006964 <rtems_cpu_usage_report_with_plugin>   <== NOT EXECUTED
                                                                      

a0006964 <rtems_cpu_usage_report_with_plugin>: void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
a0006964:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
    Timestamp_Control  uptime, total, ran, uptime_at_last_reset;      
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
a0006968:	e251a000 	subs	sl, r1, #0                                   <== NOT EXECUTED
                                                                      
void rtems_cpu_usage_report_with_plugin(                              
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a000696c:	e24dd058 	sub	sp, sp, #88	; 0x58                            <== NOT EXECUTED
a0006970:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    Timestamp_Control  uptime, total, ran, uptime_at_last_reset;      
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
a0006974:	0a00006a 	beq	a0006b24 <rtems_cpu_usage_report_with_plugin+0x1c0><== NOT EXECUTED
   *  the number of "ticks" we gave credit for to give the user a rough
   *  guideline as to what each number means proportionally.          
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &total );                                 
    uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;            
a0006978:	e59f21ac 	ldr	r2, [pc, #428]	; a0006b2c <rtems_cpu_usage_report_with_plugin+0x1c8><== NOT EXECUTED
   *  When not using nanosecond CPU usage resolution, we have to count
   *  the number of "ticks" we gave credit for to give the user a rough
   *  guideline as to what each number means proportionally.          
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &total );                                 
a000697c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006980:	e58d3040 	str	r3, [sp, #64]	; 0x40                          <== NOT EXECUTED
    uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;            
a0006984:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
   *  When not using nanosecond CPU usage resolution, we have to count
   *  the number of "ticks" we gave credit for to give the user a rough
   *  guideline as to what each number means proportionally.          
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Set_to_zero( &total );                                 
a0006988:	e58d3044 	str	r3, [sp, #68]	; 0x44                          <== NOT EXECUTED
    uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;            
a000698c:	e58d1030 	str	r1, [sp, #48]	; 0x30                          <== NOT EXECUTED
a0006990:	e58d2034 	str	r2, [sp, #52]	; 0x34                          <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
a0006994:	e59f1194 	ldr	r1, [pc, #404]	; a0006b30 <rtems_cpu_usage_report_with_plugin+0x1cc><== NOT EXECUTED
a0006998:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
a000699c:	e59f1190 	ldr	r1, [pc, #400]	; a0006b34 <rtems_cpu_usage_report_with_plugin+0x1d0><== NOT EXECUTED
        the_thread = (Thread_Control *)information->local_table[ i ]; 
                                                                      
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
a00069a0:	e28d8010 	add	r8, sp, #16                                   <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
a00069a4:	e58d100c 	str	r1, [sp, #12]                                 <== NOT EXECUTED
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
a00069a8:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
a00069ac:	e5b23004 	ldr	r3, [r2, #4]!                                 <== NOT EXECUTED
a00069b0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00069b4:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
a00069b8:	0a00004d 	beq	a0006af4 <rtems_cpu_usage_report_with_plugin+0x190><== NOT EXECUTED
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
a00069bc:	e5936004 	ldr	r6, [r3, #4]                                  <== NOT EXECUTED
    if ( information ) {                                              
a00069c0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a00069c4:	0a00004a 	beq	a0006af4 <rtems_cpu_usage_report_with_plugin+0x190><== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
a00069c8:	e1d631b0 	ldrh	r3, [r6, #16]                                <== NOT EXECUTED
a00069cc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00069d0:	0a000047 	beq	a0006af4 <rtems_cpu_usage_report_with_plugin+0x190><== NOT EXECUTED
a00069d4:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
            _Timestamp_Subtract( &last, &uptime, &used );             
            _Timestamp_Add_to( &ran, &used );                         
          } else {                                                    
            _TOD_Get_uptime( &uptime );                               
          }                                                           
          _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
a00069d8:	e28db040 	add	fp, sp, #64	; 0x40                            <== NOT EXECUTED
            Timestamp_Control last = _Thread_Time_of_last_context_switch;
            _TOD_Get_uptime( &uptime );                               
            _Timestamp_Subtract( &last, &uptime, &used );             
            _Timestamp_Add_to( &ran, &used );                         
          } else {                                                    
            _TOD_Get_uptime( &uptime );                               
a00069dc:	e28d7048 	add	r7, sp, #72	; 0x48                            <== NOT EXECUTED
a00069e0:	ea00001a 	b	a0006a50 <rtems_cpu_usage_report_with_plugin+0xec><== NOT EXECUTED
a00069e4:	eb00162c 	bl	a000c29c <_TOD_Get_uptime>                     <== NOT EXECUTED
a00069e8:	e28d4038 	add	r4, sp, #56	; 0x38                            <== NOT EXECUTED
          }                                                           
          _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
a00069ec:	e28d0030 	add	r0, sp, #48	; 0x30                            <== NOT EXECUTED
a00069f0:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00069f4:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a00069f8:	eb001f4a 	bl	a000e728 <_Timespec_Subtract>                  <== NOT EXECUTED
          _Timestamp_Divide( &ran, &total, &ival, &fval );            
a00069fc:	e28d2054 	add	r2, sp, #84	; 0x54                            <== NOT EXECUTED
a0006a00:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006a04:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
a0006a08:	e28d3050 	add	r3, sp, #80	; 0x50                            <== NOT EXECUTED
a0006a0c:	eb001f1e 	bl	a000e68c <_Timespec_Divide>                    <== NOT EXECUTED
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          (*print)( context,                                          
a0006a10:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
a0006a14:	e59f111c 	ldr	r1, [pc, #284]	; a0006b38 <rtems_cpu_usage_report_with_plugin+0x1d4><== NOT EXECUTED
a0006a18:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0006a1c:	e0832391 	umull	r2, r3, r1, r3                              <== NOT EXECUTED
a0006a20:	e59d2054 	ldr	r2, [sp, #84]	; 0x54                          <== NOT EXECUTED
a0006a24:	e1a03323 	lsr	r3, r3, #6                                    <== NOT EXECUTED
a0006a28:	e59f110c 	ldr	r1, [pc, #268]	; a0006b3c <rtems_cpu_usage_report_with_plugin+0x1d8><== NOT EXECUTED
a0006a2c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0006a30:	e59d2050 	ldr	r2, [sp, #80]	; 0x50                          <== NOT EXECUTED
a0006a34:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a0006a38:	e59d2038 	ldr	r2, [sp, #56]	; 0x38                          <== NOT EXECUTED
a0006a3c:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
a0006a40:	e1d631b0 	ldrh	r3, [r6, #16]                                <== NOT EXECUTED
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
a0006a44:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
a0006a48:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a0006a4c:	3a000028 	bcc	a0006af4 <rtems_cpu_usage_report_with_plugin+0x190><== NOT EXECUTED
        the_thread = (Thread_Control *)information->local_table[ i ]; 
a0006a50:	e596001c 	ldr	r0, [r6, #28]                                 <== NOT EXECUTED
                                                                      
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
a0006a54:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a0006a58:	e3a0100d 	mov	r1, #13                                       <== NOT EXECUTED
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
a0006a5c:	e7904105 	ldr	r4, [r0, r5, lsl #2]                          <== NOT EXECUTED
                                                                      
        if ( !the_thread )                                            
a0006a60:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0006a64:	0afffff6 	beq	a0006a44 <rtems_cpu_usage_report_with_plugin+0xe0><== NOT EXECUTED
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
a0006a68:	e5940008 	ldr	r0, [r4, #8]                                  <== NOT EXECUTED
a0006a6c:	eb00113a 	bl	a000af5c <rtems_object_get_name>               <== NOT EXECUTED
                                                                      
        (*print)(                                                     
a0006a70:	e1a03008 	mov	r3, r8                                        <== NOT EXECUTED
a0006a74:	e5942008 	ldr	r2, [r4, #8]                                  <== NOT EXECUTED
a0006a78:	e59f10c0 	ldr	r1, [pc, #192]	; a0006b40 <rtems_cpu_usage_report_with_plugin+0x1dc><== NOT EXECUTED
a0006a7c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0006a80:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
        #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                    
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
a0006a84:	e2841084 	add	r1, r4, #132	; 0x84                           <== NOT EXECUTED
a0006a88:	e8910003 	ldm	r1, {r0, r1}                                  <== NOT EXECUTED
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
a0006a8c:	e59f30b0 	ldr	r3, [pc, #176]	; a0006b44 <rtems_cpu_usage_report_with_plugin+0x1e0><== NOT EXECUTED
a0006a90:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a0006a94:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
        #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                    
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
a0006a98:	e58d0038 	str	r0, [sp, #56]	; 0x38                          <== NOT EXECUTED
a0006a9c:	e58d103c 	str	r1, [sp, #60]	; 0x3c                          <== NOT EXECUTED
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
a0006aa0:	e5922008 	ldr	r2, [r2, #8]                                  <== NOT EXECUTED
            Timestamp_Control last = _Thread_Time_of_last_context_switch;
            _TOD_Get_uptime( &uptime );                               
            _Timestamp_Subtract( &last, &uptime, &used );             
            _Timestamp_Add_to( &ran, &used );                         
          } else {                                                    
            _TOD_Get_uptime( &uptime );                               
a0006aa4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
          if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
a0006aa8:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0006aac:	1affffcc 	bne	a00069e4 <rtems_cpu_usage_report_with_plugin+0x80><== NOT EXECUTED
            Timestamp_Control used;                                   
            Timestamp_Control last = _Thread_Time_of_last_context_switch;
a0006ab0:	e59fc090 	ldr	ip, [pc, #144]	; a0006b48 <rtems_cpu_usage_report_with_plugin+0x1e4><== NOT EXECUTED
a0006ab4:	e89c0018 	ldm	ip, {r3, r4}                                  <== NOT EXECUTED
a0006ab8:	e58d3020 	str	r3, [sp, #32]                                 <== NOT EXECUTED
a0006abc:	e58d4024 	str	r4, [sp, #36]	; 0x24                          <== NOT EXECUTED
            _TOD_Get_uptime( &uptime );                               
a0006ac0:	eb0015f5 	bl	a000c29c <_TOD_Get_uptime>                     <== NOT EXECUTED
            _Timestamp_Subtract( &last, &uptime, &used );             
a0006ac4:	e28d3028 	add	r3, sp, #40	; 0x28                            <== NOT EXECUTED
a0006ac8:	e28d0020 	add	r0, sp, #32                                   <== NOT EXECUTED
a0006acc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0006ad0:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0006ad4:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
a0006ad8:	eb001f12 	bl	a000e728 <_Timespec_Subtract>                  <== NOT EXECUTED
            _Timestamp_Add_to( &ran, &used );                         
a0006adc:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0006ae0:	e28d4038 	add	r4, sp, #56	; 0x38                            <== NOT EXECUTED
a0006ae4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006ae8:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0006aec:	eb001ecf 	bl	a000e630 <_Timespec_Add_to>                    <== NOT EXECUTED
a0006af0:	eaffffbd 	b	a00069ec <rtems_cpu_usage_report_with_plugin+0x88><== NOT EXECUTED
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
a0006af4:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0006af8:	e59fc04c 	ldr	ip, [pc, #76]	; a0006b4c <rtems_cpu_usage_report_with_plugin+0x1e8><== NOT EXECUTED
a0006afc:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a0006b00:	1affffa8 	bne	a00069a8 <rtems_cpu_usage_report_with_plugin+0x44><== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)(                                                         
a0006b04:	e59d2044 	ldr	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
a0006b08:	e59f3028 	ldr	r3, [pc, #40]	; a0006b38 <rtems_cpu_usage_report_with_plugin+0x1d4><== NOT EXECUTED
a0006b0c:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0006b10:	e59f1038 	ldr	r1, [pc, #56]	; a0006b50 <rtems_cpu_usage_report_with_plugin+0x1ec><== NOT EXECUTED
a0006b14:	e083c392 	umull	ip, r3, r2, r3                              <== NOT EXECUTED
a0006b18:	e59d2040 	ldr	r2, [sp, #64]	; 0x40                          <== NOT EXECUTED
a0006b1c:	e1a03323 	lsr	r3, r3, #6                                    <== NOT EXECUTED
a0006b20:	e12fff3a 	blx	sl                                            <== NOT EXECUTED
       "-------------------------------------------------------------------------------\n",
       _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,    
       total_units                                                    
    );                                                                
  #endif                                                              
}                                                                     
a0006b24:	e28dd058 	add	sp, sp, #88	; 0x58                            <== NOT EXECUTED
a0006b28:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

a0006b74 <rtems_cpu_usage_reset>: /* * rtems_cpu_usage_reset */ void rtems_cpu_usage_reset( void ) {
a0006b74:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );               
a0006b78:	e59f401c 	ldr	r4, [pc, #28]	; a0006b9c <rtems_cpu_usage_reset+0x28><== NOT EXECUTED
a0006b7c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006b80:	eb0015c5 	bl	a000c29c <_TOD_Get_uptime>                     <== NOT EXECUTED
    _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
a0006b84:	e8940006 	ldm	r4, {r1, r2}                                  <== NOT EXECUTED
a0006b88:	e59f3010 	ldr	r3, [pc, #16]	; a0006ba0 <rtems_cpu_usage_reset+0x2c><== NOT EXECUTED
  #else                                                               
    CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;       
  #endif                                                              
                                                                      
  rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);       
a0006b8c:	e59f0010 	ldr	r0, [pc, #16]	; a0006ba4 <rtems_cpu_usage_reset+0x30><== NOT EXECUTED
 */                                                                   
void rtems_cpu_usage_reset( void )                                    
{                                                                     
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );               
    _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
a0006b90:	e8830006 	stm	r3, {r1, r2}                                  <== NOT EXECUTED
  #else                                                               
    CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;       
  #endif                                                              
                                                                      
  rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);       
}                                                                     
a0006b94:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
    _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
  #else                                                               
    CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;       
  #endif                                                              
                                                                      
  rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);       
a0006b98:	ea001743 	b	a000c8ac <rtems_iterate_over_all_threads>       <== NOT EXECUTED
                                                                      

a000f02c <rtems_debug_disable>: */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled;
a000f02c:	e59f300c 	ldr	r3, [pc, #12]	; a000f040 <rtems_debug_disable+0x14><== NOT EXECUTED
a000f030:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000f034:	e1c22000 	bic	r2, r2, r0                                    <== NOT EXECUTED
a000f038:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
}                                                                     
a000f03c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000f014 <rtems_debug_enable>: */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { _Debug_Level |= to_be_enabled;
a000f014:	e59f300c 	ldr	r3, [pc, #12]	; a000f028 <rtems_debug_enable+0x14><== NOT EXECUTED
a000f018:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000f01c:	e1802002 	orr	r2, r0, r2                                    <== NOT EXECUTED
a000f020:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
}                                                                     
a000f024:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000f044 <rtems_debug_is_enabled>: */ bool rtems_debug_is_enabled( rtems_debug_control level ) { return (_Debug_Level & level) ? true : false;
a000f044:	e59f3010 	ldr	r3, [pc, #16]	; a000f05c <rtems_debug_is_enabled+0x18><== NOT EXECUTED
a000f048:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000f04c:	e1100003 	tst	r0, r3                                        <== NOT EXECUTED
}                                                                     
a000f050:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
a000f054:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
a000f058:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0011094 <rtems_deviceio_errno>: [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) {
a0011094:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
  [RTEMS_IO_ERROR]                 = EIO,                             
  [RTEMS_PROXY_BLOCKING]           = EIO                              
};                                                                    
                                                                      
int rtems_deviceio_errno(rtems_status_code sc)                        
{                                                                     
a0011098:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if (sc == RTEMS_SUCCESSFUL) {                                       
a001109c:	1a000001 	bne	a00110a8 <rtems_deviceio_errno+0x14>          <== NOT EXECUTED
                                                                      
    errno = eno;                                                      
                                                                      
    return -1;                                                        
  }                                                                   
}                                                                     
a00110a0:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a00110a4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  if (sc == RTEMS_SUCCESSFUL) {                                       
    return 0;                                                         
  } else {                                                            
    int eno = EINVAL;                                                 
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
a00110a8:	e353001c 	cmp	r3, #28                                       <== NOT EXECUTED
      eno = status_code_to_errno [sc];                                
a00110ac:	959f2014 	ldrls	r2, [pc, #20]	; a00110c8 <rtems_deviceio_errno+0x34><== NOT EXECUTED
int rtems_deviceio_errno(rtems_status_code sc)                        
{                                                                     
  if (sc == RTEMS_SUCCESSFUL) {                                       
    return 0;                                                         
  } else {                                                            
    int eno = EINVAL;                                                 
a00110b0:	83a04016 	movhi	r4, #22                                     <== NOT EXECUTED
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
      eno = status_code_to_errno [sc];                                
a00110b4:	97924103 	ldrls	r4, [r2, r3, lsl #2]                        <== NOT EXECUTED
    }                                                                 
                                                                      
    errno = eno;                                                      
a00110b8:	eb000008 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
                                                                      
    return -1;                                                        
a00110bc:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
      eno = status_code_to_errno [sc];                                
    }                                                                 
                                                                      
    errno = eno;                                                      
a00110c0:	e5804000 	str	r4, [r0]                                      <== NOT EXECUTED
                                                                      
    return -1;                                                        
a00110c4:	eafffff5 	b	a00110a0 <rtems_deviceio_errno+0xc>             <== NOT EXECUTED
                                                                      

a000af7c <rtems_error>: int rtems_error( rtems_error_code_t error_flag, const char *printf_format, ... ) {
a000af7c:	e92d000e 	push	{r1, r2, r3}                                 <== NOT EXECUTED
a000af80:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000af84:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  va_list arglist;                                                    
  int chars_written;                                                  
                                                                      
  va_start(arglist, printf_format);                                   
a000af88:	e28d3010 	add	r3, sp, #16                                   <== NOT EXECUTED
int rtems_error(                                                      
  rtems_error_code_t error_flag,                                      
  const char *printf_format,                                          
  ...                                                                 
)                                                                     
{                                                                     
a000af8c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  va_list arglist;                                                    
  int chars_written;                                                  
                                                                      
  va_start(arglist, printf_format);                                   
  chars_written = rtems_verror(error_flag, printf_format, arglist);   
a000af90:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000af94:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  va_list arglist;                                                    
  int chars_written;                                                  
                                                                      
  va_start(arglist, printf_format);                                   
a000af98:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  chars_written = rtems_verror(error_flag, printf_format, arglist);   
a000af9c:	ebffff9c 	bl	a000ae14 <rtems_verror>                        <== NOT EXECUTED
  va_end(arglist);                                                    
                                                                      
  if (error_flag & RTEMS_ERROR_PANIC) {                               
a000afa0:	e2143202 	ands	r3, r4, #536870912	; 0x20000000              <== NOT EXECUTED
a000afa4:	1a000005 	bne	a000afc0 <rtems_error+0x44>                   <== NOT EXECUTED
    rtems_error(0, "fatal error, exiting");                           
    _exit(errno);                                                     
  }                                                                   
  if (error_flag & RTEMS_ERROR_ABORT) {                               
a000afa8:	e3140201 	tst	r4, #268435456	; 0x10000000                   <== NOT EXECUTED
a000afac:	1a000009 	bne	a000afd8 <rtems_error+0x5c>                   <== NOT EXECUTED
    rtems_error(0, "fatal error, aborting");                          
    abort();                                                          
  }                                                                   
                                                                      
  return chars_written;                                               
}                                                                     
a000afb0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000afb4:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
a000afb8:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a000afbc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  va_start(arglist, printf_format);                                   
  chars_written = rtems_verror(error_flag, printf_format, arglist);   
  va_end(arglist);                                                    
                                                                      
  if (error_flag & RTEMS_ERROR_PANIC) {                               
    rtems_error(0, "fatal error, exiting");                           
a000afc0:	e59f1020 	ldr	r1, [pc, #32]	; a000afe8 <rtems_error+0x6c>   <== NOT EXECUTED
a000afc4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000afc8:	ebffffeb 	bl	a000af7c <rtems_error>                         <== NOT EXECUTED
    _exit(errno);                                                     
a000afcc:	eb002e10 	bl	a0016814 <__errno>                             <== NOT EXECUTED
a000afd0:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a000afd4:	eb0002d1 	bl	a000bb20 <_exit>                               <== NOT EXECUTED
  }                                                                   
  if (error_flag & RTEMS_ERROR_ABORT) {                               
    rtems_error(0, "fatal error, aborting");                          
a000afd8:	e59f100c 	ldr	r1, [pc, #12]	; a000afec <rtems_error+0x70>   <== NOT EXECUTED
a000afdc:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a000afe0:	ebffffe5 	bl	a000af7c <rtems_error>                         <== NOT EXECUTED
    abort();                                                          
a000afe4:	eb002e00 	bl	a00167ec <abort>                               <== NOT EXECUTED
                                                                      

a000946c <rtems_event_receive>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
a000946c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !event_out )                                                   
a0009470:	e2536000 	subs	r6, r3, #0                                   <== NOT EXECUTED
a0009474:	0a000010 	beq	a00094bc <rtems_event_receive+0x50>           <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];        
a0009478:	e59f4044 	ldr	r4, [pc, #68]	; a00094c4 <rtems_event_receive+0x58><== NOT EXECUTED
                                                                      
  if ( _Event_sets_Is_empty( event_in ) ) {                           
a000947c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !event_out )                                                   
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];        
a0009480:	e5945004 	ldr	r5, [r4, #4]                                  <== NOT EXECUTED
a0009484:	e59550f4 	ldr	r5, [r5, #244]	; 0xf4                         <== NOT EXECUTED
                                                                      
  if ( _Event_sets_Is_empty( event_in ) ) {                           
a0009488:	1a000002 	bne	a0009498 <rtems_event_receive+0x2c>           <== NOT EXECUTED
    *event_out = api->pending_events;                                 
a000948c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0009490:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0009494:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a0009498:	e59fc028 	ldr	ip, [pc, #40]	; a00094c8 <rtems_event_receive+0x5c><== NOT EXECUTED
a000949c:	e59ce000 	ldr	lr, [ip]                                      <== NOT EXECUTED
a00094a0:	e28ee001 	add	lr, lr, #1                                    <== NOT EXECUTED
a00094a4:	e58ce000 	str	lr, [ip]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  _Thread_Disable_dispatch();                                         
  _Event_Seize( event_in, option_set, ticks, event_out );             
a00094a8:	eb000007 	bl	a00094cc <_Event_Seize>                        <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a00094ac:	eb000ac7 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return( _Thread_Executing->Wait.return_code );                      
a00094b0:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a00094b4:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
a00094b8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
)                                                                     
{                                                                     
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !event_out )                                                   
    return RTEMS_INVALID_ADDRESS;                                     
a00094bc:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();                                         
  _Event_Seize( event_in, option_set, ticks, event_out );             
  _Thread_Enable_dispatch();                                          
  return( _Thread_Executing->Wait.return_code );                      
}                                                                     
a00094c0:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a00095e0 <rtems_event_send>: rtems_status_code rtems_event_send( rtems_id id, rtems_event_set event_in ) {
a00095e0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a00095e4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00095e8:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a00095ec:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00095f0:	eb000a7f 	bl	a000bff4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a00095f4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a00095f8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00095fc:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a0009600:	1a00000a 	bne	a0009630 <rtems_event_send+0x50>              <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
a0009604:	e59030f4 	ldr	r3, [r0, #244]	; 0xf4                         <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0009608:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000960c:	e3821080 	orr	r1, r2, #128	; 0x80                           <== NOT EXECUTED
a0009610:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
    *the_event_set |= the_new_events;                                 
a0009614:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a0009618:	e1814004 	orr	r4, r1, r4                                    <== NOT EXECUTED
a000961c:	e5834000 	str	r4, [r3]                                      <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0009620:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
      _Event_sets_Post( event_in, &api->pending_events );             
      _Event_Surrender( the_thread );                                 
a0009624:	eb000003 	bl	a0009638 <_Event_Surrender>                    <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0009628:	eb000a68 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000962c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009630:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0009634:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000ba24 <rtems_extension_create>: rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) {
a000ba24:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  Extension_Control *the_extension;                                   
                                                                      
  if ( !id )                                                          
a000ba28:	e2526000 	subs	r6, r2, #0                                   <== NOT EXECUTED
rtems_status_code rtems_extension_create(                             
  rtems_name                    name,                                 
  const rtems_extensions_table *extension_table,                      
  rtems_id                     *id                                    
)                                                                     
{                                                                     
a000ba2c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000ba30:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
  Extension_Control *the_extension;                                   
                                                                      
  if ( !id )                                                          
a000ba34:	0a000020 	beq	a000babc <rtems_extension_create+0x98>        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000ba38:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ba3c:	1a000001 	bne	a000ba48 <rtems_extension_create+0x24>        <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
a000ba40:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
  );                                                                  
                                                                      
  *id = the_extension->Object.id;                                     
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000ba44:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000ba48:	e59f3074 	ldr	r3, [pc, #116]	; a000bac4 <rtems_extension_create+0xa0><== NOT EXECUTED
a000ba4c:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000ba50:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000ba54:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
#ifndef __EXTENSION_MANAGER_inl                                       
#define __EXTENSION_MANAGER_inl                                       
                                                                      
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )   
{                                                                     
  return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
a000ba58:	e59f7068 	ldr	r7, [pc, #104]	; a000bac8 <rtems_extension_create+0xa4><== NOT EXECUTED
a000ba5c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ba60:	eb0003ad 	bl	a000c91c <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();         /* to prevent deletion */       
                                                                      
  the_extension = _Extension_Allocate();                              
                                                                      
  if ( !the_extension ) {                                             
a000ba64:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a000ba68:	0a000010 	beq	a000bab0 <rtems_extension_create+0x8c>        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(        
  User_extensions_Control     *extension,                             
  const User_extensions_Table *extension_table                        
)                                                                     
{                                                                     
  extension->Callouts = *extension_table;                             
a000ba6c:	e285c024 	add	ip, r5, #36	; 0x24                            <== NOT EXECUTED
a000ba70:	e1a0e008 	mov	lr, r8                                        <== NOT EXECUTED
a000ba74:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000ba78:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000ba7c:	e89e000f 	ldm	lr, {r0, r1, r2, r3}                          <== NOT EXECUTED
a000ba80:	e88c000f 	stm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
                                                                      
  _User_extensions_Add_set( extension );                              
a000ba84:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
a000ba88:	eb000b3d 	bl	a000e784 <_User_extensions_Add_set>            <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a000ba8c:	e5953008 	ldr	r3, [r5, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000ba90:	e597201c 	ldr	r2, [r7, #28]                                 <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a000ba94:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000ba98:	e7825721 	str	r5, [r2, r1, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a000ba9c:	e585400c 	str	r4, [r5, #12]                                 <== NOT EXECUTED
    &_Extension_Information,                                          
    &the_extension->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_extension->Object.id;                                     
a000baa0:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a000baa4:	eb000841 	bl	a000dbb0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a000baa8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000baac:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */       
                                                                      
  the_extension = _Extension_Allocate();                              
                                                                      
  if ( !the_extension ) {                                             
    _Thread_Enable_dispatch();                                        
a000bab0:	eb00083e 	bl	a000dbb0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a000bab4:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a000bab8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Extension_Control *the_extension;                                   
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
a000babc:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000bac0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a000b814 <rtems_extension_delete>: #include <rtems/extension.h> rtems_status_code rtems_extension_delete( rtems_id id ) {
a000b814:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000b818:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000b81c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Extension_Control *)                                        
    _Objects_Get( &_Extension_Information, id, location );            
a000b820:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000b824:	e59f0044 	ldr	r0, [pc, #68]	; a000b870 <rtems_extension_delete+0x5c><== NOT EXECUTED
a000b828:	eb0004a2 	bl	a000cab8 <_Objects_Get>                        <== NOT EXECUTED
  Extension_Control   *the_extension;                                 
  Objects_Locations    location;                                      
                                                                      
  the_extension = _Extension_Get( id, &location );                    
  switch ( location ) {                                               
a000b82c:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a000b830:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000b834:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000b838:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Extension_Control   *the_extension;                                 
  Objects_Locations    location;                                      
                                                                      
  the_extension = _Extension_Get( id, &location );                    
  switch ( location ) {                                               
a000b83c:	1a000009 	bne	a000b868 <rtems_extension_delete+0x54>        <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      _User_extensions_Remove_set( &the_extension->Extension );       
a000b840:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
a000b844:	eb000ad4 	bl	a000e39c <_User_extensions_Remove_set>         <== NOT EXECUTED
      _Objects_Close( &_Extension_Information, &the_extension->Object );
a000b848:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000b84c:	e59f001c 	ldr	r0, [pc, #28]	; a000b870 <rtems_extension_delete+0x5c><== NOT EXECUTED
a000b850:	eb00038a 	bl	a000c680 <_Objects_Close>                      <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Extension_Free (                           
  Extension_Control *the_extension                                    
)                                                                     
{                                                                     
  _Objects_Free( &_Extension_Information, &the_extension->Object );   
a000b854:	e59f0014 	ldr	r0, [pc, #20]	; a000b870 <rtems_extension_delete+0x5c><== NOT EXECUTED
a000b858:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000b85c:	eb00043c 	bl	a000c954 <_Objects_Free>                       <== NOT EXECUTED
      _Extension_Free( the_extension );                               
      _Thread_Enable_dispatch();                                      
a000b860:	eb0007c5 	bl	a000d77c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000b864:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000b868:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000b86c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000c6b4 <rtems_extension_ident>: rtems_status_code rtems_extension_ident( rtems_name name, rtems_id *id ) {
a000c6b4:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000c6b8:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a000c6bc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a000c6c0:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a000c6c4:	e59f0010 	ldr	r0, [pc, #16]	; a000c6dc <rtems_extension_ident+0x28><== NOT EXECUTED
a000c6c8:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a000c6cc:	eb0004ca 	bl	a000d9fc <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_LOCAL_NODE,                                        
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a000c6d0:	e59f3008 	ldr	r3, [pc, #8]	; a000c6e0 <rtems_extension_ident+0x2c><== NOT EXECUTED
}                                                                     
a000c6d4:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a000c6d8:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00062d0 <rtems_filesystem_dirname>: int rtems_filesystem_dirname( const char *pathname ) {
a00062d0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a00062d4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  int len = strlen( pathname );                                       
a00062d8:	eb002f6a 	bl	a0012088 <strlen>                              <== NOT EXECUTED
                                                                      
  while ( len ) {                                                     
a00062dc:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a00062e0:	1a000002 	bne	a00062f0 <rtems_filesystem_dirname+0x20>      <== NOT EXECUTED
a00062e4:	ea000006 	b	a0006304 <rtems_filesystem_dirname+0x34>        <== NOT EXECUTED
a00062e8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a00062ec:	0a000004 	beq	a0006304 <rtems_filesystem_dirname+0x34>      <== NOT EXECUTED
    len--;                                                            
a00062f0:	e2444001 	sub	r4, r4, #1                                    <== NOT EXECUTED
    if ( rtems_filesystem_is_separator( pathname[len] ) )             
a00062f4:	e7d50004 	ldrb	r0, [r5, r4]                                 <== NOT EXECUTED
a00062f8:	eb0003eb 	bl	a00072ac <rtems_filesystem_is_separator>       <== NOT EXECUTED
a00062fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006300:	0afffff8 	beq	a00062e8 <rtems_filesystem_dirname+0x18>      <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  return len;                                                         
}                                                                     
a0006304:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006308:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0006208 <rtems_filesystem_evaluate_relative_path>: if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); #endif result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
a0006208:	e593c00c 	ldr	ip, [r3, #12]                                 
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc,                         
  int                                follow_link                      
)                                                                     
{                                                                     
a000620c:	e92d4030 	push	{r4, r5, lr}                                 
                                                                      
    if ( !pathloc )                                                   
      rtems_set_errno_and_return_minus_one( EIO );                    
  #endif                                                              
                                                                      
  result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
a0006210:	e59cc000 	ldr	ip, [ip]                                      
  size_t                             pathnamelen,                     
  int                                flags,                           
  rtems_filesystem_location_info_t  *pathloc,                         
  int                                follow_link                      
)                                                                     
{                                                                     
a0006214:	e1a04003 	mov	r4, r3                                        
a0006218:	e1a05002 	mov	r5, r2                                        
                                                                      
    if ( !pathloc )                                                   
      rtems_set_errno_and_return_minus_one( EIO );                    
  #endif                                                              
                                                                      
  result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
a000621c:	e12fff3c 	blx	ip                                            
  /*                                                                  
   * Get the Node type and determine if you need to follow the link or
   * not.                                                             
   */                                                                 
                                                                      
  if ( (result == 0) && follow_link ) {                               
a0006220:	e59d200c 	ldr	r2, [sp, #12]                                 
a0006224:	e2703001 	rsbs	r3, r0, #1                                   
a0006228:	33a03000 	movcc	r3, #0                                      
a000622c:	e3520000 	cmp	r2, #0                                        
a0006230:	03a03000 	moveq	r3, #0                                      
a0006234:	e3530000 	cmp	r3, #0                                        
a0006238:	1a000000 	bne	a0006240 <rtems_filesystem_evaluate_relative_path+0x38>
        result =  (*pathloc->ops->eval_link_h)( pathloc, flags );     
    }                                                                 
  }                                                                   
                                                                      
  return result;                                                      
}                                                                     
a000623c:	e8bd8030 	pop	{r4, r5, pc}                                  
   * not.                                                             
   */                                                                 
                                                                      
  if ( (result == 0) && follow_link ) {                               
                                                                      
    type = (*pathloc->ops->node_type_h)( pathloc );                   
a0006240:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a0006244:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006248:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000624c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
    if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||                    
a0006250:	e2400003 	sub	r0, r0, #3                                    <== NOT EXECUTED
a0006254:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a0006258:	83a00000 	movhi	r0, #0                                      <== NOT EXECUTED
a000625c:	8afffff6 	bhi	a000623c <rtems_filesystem_evaluate_relative_path+0x34><== NOT EXECUTED
         *    pathloc will be passed up (and eventually released).    
         *    Hence, the (valid) originial node that we submit to     
         *    eval_link_h() should be released by the handler.        
         */                                                           
                                                                      
        result =  (*pathloc->ops->eval_link_h)( pathloc, flags );     
a0006260:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a0006264:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006268:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000626c:	e5933034 	ldr	r3, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0006270:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0006274:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0007240 <rtems_filesystem_get_start_loc>: #include "rtems/libio_.h" void rtems_filesystem_get_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) {
a0007240:	e92d4070 	push	{r4, r5, r6, lr}                             
  if (rtems_filesystem_is_separator(path[0])) {                       
a0007244:	e5d00000 	ldrb	r0, [r0]                                     
#include "rtems/libio_.h"                                             
                                                                      
void rtems_filesystem_get_start_loc(const char *path,                 
				    int *index,                                                   
				    rtems_filesystem_location_info_t *loc)                        
{                                                                     
a0007248:	e1a05001 	mov	r5, r1                                        
a000724c:	e1a04002 	mov	r4, r2                                        
  if (rtems_filesystem_is_separator(path[0])) {                       
a0007250:	eb000015 	bl	a00072ac <rtems_filesystem_is_separator>       
a0007254:	e2506000 	subs	r6, r0, #0                                   
a0007258:	1a000008 	bne	a0007280 <rtems_filesystem_get_start_loc+0x40>
    *loc = rtems_filesystem_root;                                     
    *index = 1;                                                       
  }                                                                   
  else {                                                              
    *loc = rtems_filesystem_current;                                  
a000725c:	e59f3044 	ldr	r3, [pc, #68]	; a00072a8 <rtems_filesystem_get_start_loc+0x68><== NOT EXECUTED
a0007260:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a0007264:	e28cc004 	add	ip, ip, #4                                    <== NOT EXECUTED
a0007268:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000726c:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007270:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
a0007274:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
    *index = 0;                                                       
a0007278:	e5856000 	str	r6, [r5]                                      <== NOT EXECUTED
a000727c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
void rtems_filesystem_get_start_loc(const char *path,                 
				    int *index,                                                   
				    rtems_filesystem_location_info_t *loc)                        
{                                                                     
  if (rtems_filesystem_is_separator(path[0])) {                       
    *loc = rtems_filesystem_root;                                     
a0007280:	e59f3020 	ldr	r3, [pc, #32]	; a00072a8 <rtems_filesystem_get_start_loc+0x68>
a0007284:	e593c000 	ldr	ip, [r3]                                      
a0007288:	e28cc018 	add	ip, ip, #24                                   
a000728c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         
a0007290:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}                       
a0007294:	e59c2000 	ldr	r2, [ip]                                      
    *index = 1;                                                       
a0007298:	e3a03001 	mov	r3, #1                                        
void rtems_filesystem_get_start_loc(const char *path,                 
				    int *index,                                                   
				    rtems_filesystem_location_info_t *loc)                        
{                                                                     
  if (rtems_filesystem_is_separator(path[0])) {                       
    *loc = rtems_filesystem_root;                                     
a000729c:	e5842000 	str	r2, [r4]                                      
    *index = 1;                                                       
a00072a0:	e5853000 	str	r3, [r5]                                      
a00072a4:	e8bd8070 	pop	{r4, r5, r6, pc}                              
                                                                      

a000eab8 <rtems_filesystem_get_sym_start_loc>: #include "rtems/libio_.h" void rtems_filesystem_get_sym_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) {
a000eab8:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  if (rtems_filesystem_is_separator(path[0])) {                       
a000eabc:	e5d00000 	ldrb	r0, [r0]                                     <== NOT EXECUTED
#include "rtems/libio_.h"                                             
                                                                      
void rtems_filesystem_get_sym_start_loc(const char *path,             
					int *index,                                                      
					rtems_filesystem_location_info_t *loc)                           
{                                                                     
a000eac0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a000eac4:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  if (rtems_filesystem_is_separator(path[0])) {                       
a000eac8:	ebffe1f7 	bl	a00072ac <rtems_filesystem_is_separator>       <== NOT EXECUTED
a000eacc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ead0:	1a000001 	bne	a000eadc <rtems_filesystem_get_sym_start_loc+0x24><== NOT EXECUTED
      *loc = rtems_filesystem_root;                                   
      *index = 1;                                                     
    }                                                                 
    else {                                                            
      *index = 0;                                                     
a000ead4:	e5850000 	str	r0, [r5]                                      <== NOT EXECUTED
a000ead8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
void rtems_filesystem_get_sym_start_loc(const char *path,             
					int *index,                                                      
					rtems_filesystem_location_info_t *loc)                           
{                                                                     
  if (rtems_filesystem_is_separator(path[0])) {                       
      *loc = rtems_filesystem_root;                                   
a000eadc:	e59f3020 	ldr	r3, [pc, #32]	; a000eb04 <rtems_filesystem_get_sym_start_loc+0x4c><== NOT EXECUTED
a000eae0:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
a000eae4:	e28cc018 	add	ip, ip, #24                                   <== NOT EXECUTED
a000eae8:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000eaec:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000eaf0:	e59c2000 	ldr	r2, [ip]                                      <== NOT EXECUTED
      *index = 1;                                                     
a000eaf4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
void rtems_filesystem_get_sym_start_loc(const char *path,             
					int *index,                                                      
					rtems_filesystem_location_info_t *loc)                           
{                                                                     
  if (rtems_filesystem_is_separator(path[0])) {                       
      *loc = rtems_filesystem_root;                                   
a000eaf8:	e5842000 	str	r2, [r4]                                      <== NOT EXECUTED
      *index = 1;                                                     
a000eafc:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
a000eb00:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a00060a4 <rtems_filesystem_initialize>: rtems_filesystem_umask = 022; /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 )
a00060a4:	e59f20f0 	ldr	r2, [pc, #240]	; a000619c <rtems_filesystem_initialize+0xf8>
 *  configuration is a single instantiation of the IMFS or miniIMFS with
 *  a single "/dev" directory in it.                                  
 */                                                                   
                                                                      
void rtems_filesystem_initialize( void )                              
{                                                                     
a00060a8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
a00060ac:	e59f60ec 	ldr	r6, [pc, #236]	; a00061a0 <rtems_filesystem_initialize+0xfc>
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
  if ( rtems_filesystem_mount_table_size == 0 )                       
a00060b0:	e5922000 	ldr	r2, [r2]                                      
 *  configuration is a single instantiation of the IMFS or miniIMFS with
 *  a single "/dev" directory in it.                                  
 */                                                                   
                                                                      
void rtems_filesystem_initialize( void )                              
{                                                                     
a00060b4:	e24dd018 	sub	sp, sp, #24                                   
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
a00060b8:	e5963000 	ldr	r3, [r6]                                      
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
  if ( rtems_filesystem_mount_table_size == 0 )                       
a00060bc:	e3520000 	cmp	r2, #0                                        
                                                                      
  /*                                                                  
   *  Set the default umask to "022".                                 
   */                                                                 
                                                                      
  rtems_filesystem_umask = 022;                                       
a00060c0:	e3a02012 	mov	r2, #18                                       
a00060c4:	e583202c 	str	r2, [r3, #44]	; 0x2c                          
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
  if ( rtems_filesystem_mount_table_size == 0 )                       
a00060c8:	0a00002d 	beq	a0006184 <rtems_filesystem_initialize+0xe0>   
    rtems_fatal_error_occurred( 0xABCD0001 );                         
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
a00060cc:	e59f30d0 	ldr	r3, [pc, #208]	; a00061a4 <rtems_filesystem_initialize+0x100>
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
a00060d0:	e3a05000 	mov	r5, #0                                        
   *  mount the first filesystem.                                     
   */                                                                 
  if ( rtems_filesystem_mount_table_size == 0 )                       
    rtems_fatal_error_occurred( 0xABCD0001 );                         
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
a00060d4:	e5933000 	ldr	r3, [r3]                                      
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
a00060d8:	e5930008 	ldr	r0, [r3, #8]                                  
a00060dc:	e593100c 	ldr	r1, [r3, #12]                                 
a00060e0:	e893000c 	ldm	r3, {r2, r3}                                  
a00060e4:	e58d5000 	str	r5, [sp]                                      
a00060e8:	eb000220 	bl	a0006970 <mount>                               
  if ( status == -1 )                                                 
a00060ec:	e3700001 	cmn	r0, #1                                        
a00060f0:	0a000027 	beq	a0006194 <rtems_filesystem_initialize+0xf0>   
    rtems_fatal_error_occurred( 0xABCD0002 );                         
                                                                      
  rtems_filesystem_link_counts = 0;                                   
a00060f4:	e5963000 	ldr	r3, [r6]                                      
   *       gonna hit performance.                                     
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
a00060f8:	e28d4004 	add	r4, sp, #4                                    
a00060fc:	e3a01001 	mov	r1, #1                                        
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
  if ( status == -1 )                                                 
    rtems_fatal_error_occurred( 0xABCD0002 );                         
                                                                      
  rtems_filesystem_link_counts = 0;                                   
a0006100:	e1c353b0 	strh	r5, [r3, #48]	; 0x30                         
   *       gonna hit performance.                                     
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
a0006104:	e1a02005 	mov	r2, r5                                        
a0006108:	e1a03004 	mov	r3, r4                                        
a000610c:	e59f0094 	ldr	r0, [pc, #148]	; a00061a8 <rtems_filesystem_initialize+0x104>
a0006110:	e58d5000 	str	r5, [sp]                                      
a0006114:	eb000057 	bl	a0006278 <rtems_filesystem_evaluate_path>      
  rtems_filesystem_root        = loc;                                 
a0006118:	e596c000 	ldr	ip, [r6]                                      
a000611c:	e1a07004 	mov	r7, r4                                        
a0006120:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         
a0006124:	e28cc018 	add	ip, ip, #24                                   
a0006128:	e597e000 	ldr	lr, [r7]                                      
a000612c:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
a0006130:	e3a01001 	mov	r1, #1                                        
   *                                                                  
   *       Till Straumann, 10/25/2002                                 
   */                                                                 
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
  rtems_filesystem_root        = loc;                                 
a0006134:	e58ce000 	str	lr, [ip]                                      
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
a0006138:	e1a02005 	mov	r2, r5                                        
a000613c:	e1a03004 	mov	r3, r4                                        
a0006140:	e59f0060 	ldr	r0, [pc, #96]	; a00061a8 <rtems_filesystem_initialize+0x104>
a0006144:	e58d5000 	str	r5, [sp]                                      
a0006148:	eb00004a 	bl	a0006278 <rtems_filesystem_evaluate_path>      
  rtems_filesystem_current     = loc;                                 
a000614c:	e8b4000f 	ldm	r4!, {r0, r1, r2, r3}                         
a0006150:	e596c000 	ldr	ip, [r6]                                      
a0006154:	e597e000 	ldr	lr, [r7]                                      
a0006158:	e28cc004 	add	ip, ip, #4                                    
a000615c:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).  It is actually
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  status = mkdir( "/dev", 0777);                                      
a0006160:	e3a01f7f 	mov	r1, #508	; 0x1fc                              
  /* Clone the root pathloc */                                        
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
  rtems_filesystem_root        = loc;                                 
  /* One more clone for the current node */                           
  rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);                 
  rtems_filesystem_current     = loc;                                 
a0006164:	e58ce000 	str	lr, [ip]                                      
   *                                                                  
   *  NOTE: UNIX root is 755 and owned by root/root (0/0).  It is actually
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  status = mkdir( "/dev", 0777);                                      
a0006168:	e59f003c 	ldr	r0, [pc, #60]	; a00061ac <rtems_filesystem_initialize+0x108>
a000616c:	e2811003 	add	r1, r1, #3                                    
a0006170:	eb0001a4 	bl	a0006808 <mkdir>                               
  if ( status != 0 )                                                  
a0006174:	e3500000 	cmp	r0, #0                                        
a0006178:	1a000003 	bne	a000618c <rtems_filesystem_initialize+0xe8>   
   *  it will be mounted onto is created.  Moreover, if it is going to
   *  use a device, then it is REALLY unfair to attempt this          
   *  before device drivers are initialized.  So we return via a base 
   *  filesystem image and nothing auto-mounted at this point.        
   */                                                                 
}                                                                     
a000617c:	e28dd018 	add	sp, sp, #24                                   
a0006180:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
                                                                      
  /*                                                                  
   *  mount the first filesystem.                                     
   */                                                                 
  if ( rtems_filesystem_mount_table_size == 0 )                       
    rtems_fatal_error_occurred( 0xABCD0001 );                         
a0006184:	e59f0024 	ldr	r0, [pc, #36]	; a00061b0 <rtems_filesystem_initialize+0x10c><== NOT EXECUTED
a0006188:	eb000fde 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
   *        created that way by the IMFS.                             
   */                                                                 
                                                                      
  status = mkdir( "/dev", 0777);                                      
  if ( status != 0 )                                                  
    rtems_fatal_error_occurred( 0xABCD0003 );                         
a000618c:	e59f0020 	ldr	r0, [pc, #32]	; a00061b4 <rtems_filesystem_initialize+0x110><== NOT EXECUTED
a0006190:	eb000fdc 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      
  mt = &rtems_filesystem_mount_table[0];                              
                                                                      
  status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
  if ( status == -1 )                                                 
    rtems_fatal_error_occurred( 0xABCD0002 );                         
a0006194:	e59f001c 	ldr	r0, [pc, #28]	; a00061b8 <rtems_filesystem_initialize+0x114><== NOT EXECUTED
a0006198:	eb000fda 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a000e858 <rtems_filesystem_iterate>: bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) {
a000e858:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
a000e85c:	e59f60a4 	ldr	r6, [pc, #164]	; a000e908 <rtems_filesystem_iterate+0xb0>
                                                                      
bool rtems_filesystem_iterate(                                        
  rtems_per_filesystem_routine routine,                               
  void *routine_arg                                                   
)                                                                     
{                                                                     
a000e860:	e1a04000 	mov	r4, r0                                        
a000e864:	e1a05001 	mov	r5, r1                                        
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
a000e868:	e5963000 	ldr	r3, [r6]                                      
a000e86c:	e3530000 	cmp	r3, #0                                        
a000e870:	1a000002 	bne	a000e880 <rtems_filesystem_iterate+0x28>      
a000e874:	ea00000b 	b	a000e8a8 <rtems_filesystem_iterate+0x50>        <== NOT EXECUTED
a000e878:	e3500000 	cmp	r0, #0                                        
a000e87c:	1a00001f 	bne	a000e900 <rtems_filesystem_iterate+0xa8>      
    stop = (*routine)( table_entry, routine_arg );                    
a000e880:	e1a00006 	mov	r0, r6                                        
a000e884:	e1a01005 	mov	r1, r5                                        
a000e888:	e12fff34 	blx	r4                                            
{                                                                     
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
a000e88c:	e5963008 	ldr	r3, [r6, #8]                                  
    stop = (*routine)( table_entry, routine_arg );                    
a000e890:	e1a0a000 	mov	sl, r0                                        
{                                                                     
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  while ( table_entry->type && !stop ) {                              
a000e894:	e2866008 	add	r6, r6, #8                                    
a000e898:	e3530000 	cmp	r3, #0                                        
a000e89c:	1afffff5 	bne	a000e878 <rtems_filesystem_iterate+0x20>      
    stop = (*routine)( table_entry, routine_arg );                    
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
a000e8a0:	e3500000 	cmp	r0, #0                                        
a000e8a4:	1a000015 	bne	a000e900 <rtems_filesystem_iterate+0xa8>      
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000e8a8:	e59f705c 	ldr	r7, [pc, #92]	; a000e90c <rtems_filesystem_iterate+0xb4><== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
}                                                                     
a000e8ac:	e59f605c 	ldr	r6, [pc, #92]	; a000e910 <rtems_filesystem_iterate+0xb8><== NOT EXECUTED
a000e8b0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000e8b4:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a000e8b8:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000e8bc:	ebffec6a 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
a000e8c0:	e4968004 	ldr	r8, [r6], #4                                  <== NOT EXECUTED
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
a000e8c4:	e1580006 	cmp	r8, r6                                        <== NOT EXECUTED
a000e8c8:	03a0a000 	moveq	sl, #0                                      <== NOT EXECUTED
a000e8cc:	1a000002 	bne	a000e8dc <rtems_filesystem_iterate+0x84>      <== NOT EXECUTED
a000e8d0:	ea000008 	b	a000e8f8 <rtems_filesystem_iterate+0xa0>        <== NOT EXECUTED
      node = rtems_chain_first( &filesystem_chain );                  
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
a000e8d4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e8d8:	1a000006 	bne	a000e8f8 <rtems_filesystem_iterate+0xa0>      <== NOT EXECUTED
      node = rtems_chain_next( node )                                 
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
a000e8dc:	e2880008 	add	r0, r8, #8                                    <== NOT EXECUTED
a000e8e0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000e8e4:	e12fff34 	blx	r4                                            <== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
}                                                                     
a000e8e8:	e5988000 	ldr	r8, [r8]                                      <== NOT EXECUTED
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
      node = rtems_chain_next( node )                                 
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
a000e8ec:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
a000e8f0:	e1580006 	cmp	r8, r6                                        <== NOT EXECUTED
a000e8f4:	1afffff6 	bne	a000e8d4 <rtems_filesystem_iterate+0x7c>      <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000e8f8:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a000e8fc:	ebffeca3 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
    }                                                                 
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  return stop;                                                        
}                                                                     
a000e900:	e1a0000a 	mov	r0, sl                                        
a000e904:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  
                                                                      

a00068fc <rtems_filesystem_mount_iterate>: bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) {
a00068fc:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a0006900:	e59f7060 	ldr	r7, [pc, #96]	; a0006968 <rtems_filesystem_mount_iterate+0x6c><== NOT EXECUTED
    stop = (*routine)( mt_entry, routine_arg );                       
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return stop;                                                        
}                                                                     
a0006904:	e59f4060 	ldr	r4, [pc, #96]	; a000696c <rtems_filesystem_mount_iterate+0x70><== NOT EXECUTED
                                                                      
bool rtems_filesystem_mount_iterate(                                  
  rtems_per_filesystem_mount_routine routine,                         
  void *routine_arg                                                   
)                                                                     
{                                                                     
a0006908:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a000690c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0006910:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0006914:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0006918:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a000691c:	eb000c52 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
    stop = (*routine)( mt_entry, routine_arg );                       
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return stop;                                                        
}                                                                     
a0006920:	e4948004 	ldr	r8, [r4], #4                                  <== NOT EXECUTED
{                                                                     
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
a0006924:	e1580004 	cmp	r8, r4                                        <== NOT EXECUTED
  rtems_per_filesystem_mount_routine routine,                         
  void *routine_arg                                                   
)                                                                     
{                                                                     
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
a0006928:	03a0a000 	moveq	sl, #0                                      <== NOT EXECUTED
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
a000692c:	1a000002 	bne	a000693c <rtems_filesystem_mount_iterate+0x40><== NOT EXECUTED
a0006930:	ea000008 	b	a0006958 <rtems_filesystem_mount_iterate+0x5c>  <== NOT EXECUTED
    node = rtems_chain_first( &mount_chain );                         
    !rtems_chain_is_tail( &mount_chain, node ) && !stop;              
a0006934:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006938:	1a000006 	bne	a0006958 <rtems_filesystem_mount_iterate+0x5c><== NOT EXECUTED
    node = rtems_chain_next( node )                                   
  ) {                                                                 
    const rtems_filesystem_mount_table_entry_t *mt_entry =            
      (rtems_filesystem_mount_table_entry_t *) node;                  
                                                                      
    stop = (*routine)( mt_entry, routine_arg );                       
a000693c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0006940:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0006944:	e12fff35 	blx	r5                                            <== NOT EXECUTED
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return stop;                                                        
}                                                                     
a0006948:	e5988000 	ldr	r8, [r8]                                      <== NOT EXECUTED
    node = rtems_chain_next( node )                                   
  ) {                                                                 
    const rtems_filesystem_mount_table_entry_t *mt_entry =            
      (rtems_filesystem_mount_table_entry_t *) node;                  
                                                                      
    stop = (*routine)( mt_entry, routine_arg );                       
a000694c:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
{                                                                     
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
a0006950:	e1580004 	cmp	r8, r4                                        <== NOT EXECUTED
a0006954:	1afffff6 	bne	a0006934 <rtems_filesystem_mount_iterate+0x38><== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a0006958:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a000695c:	eb000c8b 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
    stop = (*routine)( mt_entry, routine_arg );                       
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return stop;                                                        
}                                                                     
a0006960:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0006964:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a000630c <rtems_filesystem_prefix_separators>: int rtems_filesystem_prefix_separators( const char *pathname, int pathnamelen ) {
a000630c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0006310:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  /*                                                                  
   * Eat any separators at start of the path.                         
   */                                                                 
  int stripped = 0;                                                   
  while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
a0006314:	e5d00000 	ldrb	r0, [r0]                                     <== NOT EXECUTED
a0006318:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a000631c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0006320:	13500000 	cmpne	r0, #0                                      <== NOT EXECUTED
a0006324:	03a04000 	moveq	r4, #0                                      <== NOT EXECUTED
a0006328:	13a04001 	movne	r4, #1                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  /*                                                                  
   * Eat any separators at start of the path.                         
   */                                                                 
  int stripped = 0;                                                   
a000632c:	13a04000 	movne	r4, #0                                      <== NOT EXECUTED
  while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
a0006330:	1a000005 	bne	a000634c <rtems_filesystem_prefix_separators+0x40><== NOT EXECUTED
a0006334:	ea000007 	b	a0006358 <rtems_filesystem_prefix_separators+0x4c><== NOT EXECUTED
a0006338:	e5f50001 	ldrb	r0, [r5, #1]!                                <== NOT EXECUTED
  {                                                                   
    pathname++;                                                       
    pathnamelen--;                                                    
    stripped++;                                                       
a000633c:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
{                                                                     
  /*                                                                  
   * Eat any separators at start of the path.                         
   */                                                                 
  int stripped = 0;                                                   
  while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
a0006340:	e1560004 	cmp	r6, r4                                        <== NOT EXECUTED
a0006344:	13500000 	cmpne	r0, #0                                      <== NOT EXECUTED
a0006348:	0a000002 	beq	a0006358 <rtems_filesystem_prefix_separators+0x4c><== NOT EXECUTED
a000634c:	eb0003d6 	bl	a00072ac <rtems_filesystem_is_separator>       <== NOT EXECUTED
a0006350:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006354:	1afffff7 	bne	a0006338 <rtems_filesystem_prefix_separators+0x2c><== NOT EXECUTED
    pathname++;                                                       
    pathnamelen--;                                                    
    stripped++;                                                       
  }                                                                   
  return stripped;                                                    
}                                                                     
a0006358:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000635c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000e948 <rtems_filesystem_register>: int rtems_filesystem_register( const char *type, rtems_filesystem_fsmount_me_t mount_h ) {
a000e948:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a000e94c:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
a000e950:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  size_t type_size = strlen(type) + 1;                                
a000e954:	eb000dcb 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a000e958:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
  size_t fsn_size = sizeof( filesystem_node ) + type_size;            
  filesystem_node *fsn = malloc( fsn_size );                          
a000e95c:	e2800011 	add	r0, r0, #17                                   <== NOT EXECUTED
a000e960:	ebffdf6a 	bl	a0006710 <malloc>                              <== NOT EXECUTED
  char *type_storage = (char *) fsn + sizeof( *fsn );                 
                                                                      
  if ( fsn == NULL )                                                  
a000e964:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
rtems_filesystem_register(                                            
  const char                    *type,                                
  rtems_filesystem_fsmount_me_t  mount_h                              
)                                                                     
{                                                                     
  size_t type_size = strlen(type) + 1;                                
a000e968:	e28aa001 	add	sl, sl, #1                                    <== NOT EXECUTED
  size_t fsn_size = sizeof( filesystem_node ) + type_size;            
  filesystem_node *fsn = malloc( fsn_size );                          
  char *type_storage = (char *) fsn + sizeof( *fsn );                 
                                                                      
  if ( fsn == NULL )                                                  
a000e96c:	0a00001f 	beq	a000e9f0 <rtems_filesystem_register+0xa8>     <== NOT EXECUTED
)                                                                     
{                                                                     
  size_t type_size = strlen(type) + 1;                                
  size_t fsn_size = sizeof( filesystem_node ) + type_size;            
  filesystem_node *fsn = malloc( fsn_size );                          
  char *type_storage = (char *) fsn + sizeof( *fsn );                 
a000e970:	e2847010 	add	r7, r4, #16                                   <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000e974:	e59f6088 	ldr	r6, [pc, #136]	; a000ea04 <rtems_filesystem_register+0xbc><== NOT EXECUTED
                                                                      
  if ( fsn == NULL )                                                  
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
                                                                      
  memcpy(type_storage, type, type_size);                              
a000e978:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000e97c:	e1a0200a 	mov	r2, sl                                        <== NOT EXECUTED
a000e980:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000e984:	eb000c03 	bl	a0011998 <memcpy>                              <== NOT EXECUTED
a000e988:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000e98c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  fsn->entry.type = type_storage;                                     
a000e990:	e5847008 	str	r7, [r4, #8]                                  <== NOT EXECUTED
  fsn->entry.mount_h = mount_h;                                       
a000e994:	e584800c 	str	r8, [r4, #12]                                 <== NOT EXECUTED
a000e998:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000e99c:	ebffec32 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
                                                                      
  rtems_libio_lock();                                                 
  if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {         
a000e9a0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000e9a4:	ebffffda 	bl	a000e914 <rtems_filesystem_get_mount_handler>  <== NOT EXECUTED
a000e9a8:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a000e9ac:	1a000006 	bne	a000e9cc <rtems_filesystem_register+0x84>     <== NOT EXECUTED
a000e9b0:	e59f0050 	ldr	r0, [pc, #80]	; a000ea08 <rtems_filesystem_register+0xc0><== NOT EXECUTED
a000e9b4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000e9b8:	ebffee8b 	bl	a000a3ec <_Chain_Append>                       <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000e9bc:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000e9c0:	ebffec72 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
                                                                      
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return 0;                                                           
a000e9c4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000e9c8:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
a000e9cc:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000e9d0:	ebffec6e 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  rtems_libio_lock();                                                 
  if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {         
    rtems_chain_append( &filesystem_chain, &fsn->node );              
  } else {                                                            
    rtems_libio_unlock();                                             
    free( fsn );                                                      
a000e9d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e9d8:	ebffde65 	bl	a0006374 <free>                                <== NOT EXECUTED
                                                                      
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a000e9dc:	eb0009bf 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e9e0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000e9e4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e9e8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  return 0;                                                           
}                                                                     
a000e9ec:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  size_t fsn_size = sizeof( filesystem_node ) + type_size;            
  filesystem_node *fsn = malloc( fsn_size );                          
  char *type_storage = (char *) fsn + sizeof( *fsn );                 
                                                                      
  if ( fsn == NULL )                                                  
    rtems_set_errno_and_return_minus_one( ENOMEM );                   
a000e9f0:	eb0009ba 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000e9f4:	e3a0300c 	mov	r3, #12                                       <== NOT EXECUTED
a000e9f8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000e9fc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000ea00:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      

a000ea0c <rtems_filesystem_unregister>: int rtems_filesystem_unregister( const char *type ) {
a000ea0c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
a000ea10:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a000ea14:	0a000020 	beq	a000ea9c <rtems_filesystem_unregister+0x90>   <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000ea18:	e59f6090 	ldr	r6, [pc, #144]	; a000eab0 <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
}                                                                     
a000ea1c:	e59f4090 	ldr	r4, [pc, #144]	; a000eab4 <rtems_filesystem_unregister+0xa8><== NOT EXECUTED
a000ea20:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000ea24:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000ea28:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000ea2c:	ebffec0e 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
a000ea30:	e4947004 	ldr	r7, [r4], #4                                  <== NOT EXECUTED
  if ( type == NULL ) {                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
a000ea34:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
a000ea38:	1a000003 	bne	a000ea4c <rtems_filesystem_unregister+0x40>   <== NOT EXECUTED
a000ea3c:	ea00000f 	b	a000ea80 <rtems_filesystem_unregister+0x74>     <== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
}                                                                     
a000ea40:	e5977000 	ldr	r7, [r7]                                      <== NOT EXECUTED
  if ( type == NULL ) {                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
a000ea44:	e1570004 	cmp	r7, r4                                        <== NOT EXECUTED
a000ea48:	0a00000c 	beq	a000ea80 <rtems_filesystem_unregister+0x74>   <== NOT EXECUTED
    !rtems_chain_is_tail( &filesystem_chain, node );                  
    node = rtems_chain_next( node )                                   
  ) {                                                                 
    filesystem_node *fsn = (filesystem_node *) node;                  
                                                                      
    if ( strcmp( fsn->entry.type, type ) == 0 ) {                     
a000ea4c:	e5970008 	ldr	r0, [r7, #8]                                  <== NOT EXECUTED
a000ea50:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000ea54:	eb000caf 	bl	a0011d18 <strcmp>                              <== NOT EXECUTED
a000ea58:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
a000ea5c:	1afffff7 	bne	a000ea40 <rtems_filesystem_unregister+0x34>   <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
a000ea60:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ea64:	ebffee6b 	bl	a000a418 <_Chain_Extract>                      <== NOT EXECUTED
      rtems_chain_extract( node );                                    
      free( fsn );                                                    
a000ea68:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ea6c:	ebffde40 	bl	a0006374 <free>                                <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000ea70:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000ea74:	ebffec45 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
      rtems_libio_unlock();                                           
                                                                      
      return 0;                                                       
a000ea78:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ea7c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
a000ea80:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000ea84:	ebffec41 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
a000ea88:	eb000994 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000ea8c:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
a000ea90:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000ea94:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
}                                                                     
a000ea98:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a000ea9c:	eb00098f 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a000eaa0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000eaa4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000eaa8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000eaac:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a000c49c <rtems_get_version_string>: #include <rtems/system.h> const char *rtems_get_version_string(void) { return _RTEMS_version; }
a000c49c:	e59f0000 	ldr	r0, [pc, #0]	; a000c4a4 <rtems_get_version_string+0x8><== NOT EXECUTED
a000c4a0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007004 <rtems_gxx_getspecific>: void *rtems_gxx_getspecific(__gthread_key_t key) {
a0007004:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0007008:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  rtems_status_code  status;                                          
  void              *p= 0;                                            
a000700c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
  key = NULL;                                                         
  return 0;                                                           
}                                                                     
                                                                      
void *rtems_gxx_getspecific(__gthread_key_t key)                      
{                                                                     
a0007010:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_status_code  status;                                          
  void              *p= 0;                                            
a0007014:	e28d2004 	add	r2, sp, #4                                    <== NOT EXECUTED
a0007018:	e5225004 	str	r5, [r2, #-4]!                                <== NOT EXECUTED
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );   
a000701c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007020:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0007024:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0007028:	eb000f8b 	bl	a000ae5c <rtems_task_variable_get>             <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL ) {                                 
a000702c:	e1500005 	cmp	r0, r5                                        <== NOT EXECUTED
    /* We do not have to do this, but what the heck ! */              
     p= key->val;                                                     
a0007030:	05940000 	ldreq	r0, [r4]                                    <== NOT EXECUTED
  rtems_status_code  status;                                          
  void              *p= 0;                                            
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );   
  if ( status == RTEMS_SUCCESSFUL ) {                                 
a0007034:	1a000001 	bne	a0007040 <rtems_gxx_getspecific+0x3c>         <== NOT EXECUTED
       p,                                                             
       rtems_task_self()                                              
    );                                                                
  #endif                                                              
  return p;                                                           
}                                                                     
a0007038:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000703c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
     p= key->val;                                                     
  } else {                                                            
    /* fisrt time, always set to zero, it is unknown the value that the others
     * threads are using at the moment of this call                   
     */                                                               
    status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
a0007040:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007044:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0007048:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a000704c:	eb000f2f 	bl	a000ad10 <rtems_task_variable_add>             <== NOT EXECUTED
    if ( status != RTEMS_SUCCESSFUL ) {                               
a0007050:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
a0007054:	1a000002 	bne	a0007064 <rtems_gxx_getspecific+0x60>         <== NOT EXECUTED
        INTERNAL_ERROR_CORE,                                          
        true,                                                         
        INTERNAL_ERROR_GXX_KEY_ADD_FAILED                             
      );                                                              
    }                                                                 
    key->val = (void *)0;                                             
a0007058:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a000705c:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
a0007060:	eafffff4 	b	a0007038 <rtems_gxx_getspecific+0x34>           <== NOT EXECUTED
    /* fisrt time, always set to zero, it is unknown the value that the others
     * threads are using at the moment of this call                   
     */                                                               
    status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
    if ( status != RTEMS_SUCCESSFUL ) {                               
      _Internal_error_Occurred(                                       
a0007064:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007068:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000706c:	e3a02015 	mov	r2, #21                                       <== NOT EXECUTED
a0007070:	eb001331 	bl	a000bd3c <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a0006f70 <rtems_gxx_key_create>: } return 0; } int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) {
a0006f70:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0006f74:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   * pointer to the buffer that will hold the value of the key itself.
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
a0006f78:	e3a00008 	mov	r0, #8                                        <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
                                                                      
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{                                                                     
a0006f7c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
   * pointer to the buffer that will hold the value of the key itself.
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
a0006f80:	eb00010b 	bl	a00073b4 <malloc>                              <== NOT EXECUTED
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
a0006f84:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
   * pointer to the buffer that will hold the value of the key itself.
   * We have to to this, because the others functions on this interface
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
a0006f88:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  *key = new_key;                                                     
a0006f8c:	e5860000 	str	r0, [r6]                                      <== NOT EXECUTED
      "gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
    );                                                                
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
a0006f90:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006f94:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0006f98:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
   * deal with the value of the key, as used with the POSIX API.      
   */                                                                 
   /* Do not pull your hair, trust me this works. :-) */              
  __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
a0006f9c:	e8840028 	stm	r4, {r3, r5}                                  <== NOT EXECUTED
      "gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
    );                                                                
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
a0006fa0:	eb000f5a 	bl	a000ad10 <rtems_task_variable_add>             <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL )                                   
a0006fa4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006fa8:	1a000000 	bne	a0006fb0 <rtems_gxx_key_create+0x40>          <== NOT EXECUTED
    return 0;                                                         
                                                                      
  free( new_key );                                                    
  return -1;                                                          
}                                                                     
a0006fac:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
  if ( status == RTEMS_SUCCESSFUL )                                   
    return 0;                                                         
                                                                      
  free( new_key );                                                    
a0006fb0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006fb4:	ebffff7b 	bl	a0006da8 <free>                                <== NOT EXECUTED
  return -1;                                                          
a0006fb8:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0006fbc:	eafffffa 	b	a0006fac <rtems_gxx_key_create+0x3c>            <== NOT EXECUTED
                                                                      

a0006fd0 <rtems_gxx_key_delete>: int rtems_gxx_key_delete (__gthread_key_t key) {
a0006fd0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: delete key=%x\n", key );                   
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );    
a0006fd4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  key->val  = 0;                                                      
  return 0;                                                           
}                                                                     
                                                                      
int rtems_gxx_key_delete (__gthread_key_t key)                        
{                                                                     
a0006fd8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: delete key=%x\n", key );                   
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );    
a0006fdc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006fe0:	eb000f76 	bl	a000adc0 <rtems_task_variable_delete>          <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL ) {                                 
a0006fe4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006fe8:	1a000003 	bne	a0006ffc <rtems_gxx_key_delete+0x2c>          <== NOT EXECUTED
    /* Hmm - hopefully all tasks using this key have gone away... */  
    if ( key ) free( *(void **)key );                                 
a0006fec:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0006ff0:	0a000001 	beq	a0006ffc <rtems_gxx_key_delete+0x2c>          <== NOT EXECUTED
a0006ff4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0006ff8:	ebffff6a 	bl	a0006da8 <free>                                <== NOT EXECUTED
    return 0;                                                         
  }                                                                   
  key = NULL;                                                         
  return 0;                                                           
}                                                                     
a0006ffc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007000:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0006fc0 <rtems_gxx_key_dtor>: { #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: dtor key=%x, ptr=%x\n", key, ptr ); #endif key->val = 0;
a0006fc0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006fc4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0006fc8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0006fcc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007104 <rtems_gxx_mutex_destroy>: int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex) {
a0007104:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: destroy mutex=%X\n", *mutex );             
  #endif                                                              
                                                                      
  status = rtems_semaphore_delete(*(rtems_id *)mutex);                
a0007108:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a000710c:	eb000d56 	bl	a000a66c <rtems_semaphore_delete>              <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL )                                   
a0007110:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return 0;                                                         
  return -1;                                                          
}                                                                     
a0007114:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0007118:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00070a0 <rtems_gxx_mutex_init>: /* * MUTEX support */ void rtems_gxx_mutex_init (__gthread_mutex_t *mutex) {
a00070a0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00070a4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
                                                                      
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: mutex init =%X\n", *mutex );               
  #endif                                                              
                                                                      
  status = rtems_semaphore_create(                                    
a00070a8:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
a00070ac:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00070b0:	e59f0028 	ldr	r0, [pc, #40]	; a00070e0 <rtems_gxx_mutex_init+0x40><== NOT EXECUTED
a00070b4:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
a00070b8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00070bc:	eb000cf9 	bl	a000a4a8 <rtems_semaphore_create>              <== NOT EXECUTED
    RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|                            
      RTEMS_INHERIT_PRIORITY|RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,   
    0,                                                                
    (rtems_id *)mutex                                                 
  );                                                                  
  if ( status != RTEMS_SUCCESSFUL ) {                                 
a00070c0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00070c4:	1a000001 	bne	a00070d0 <rtems_gxx_mutex_init+0x30>          <== NOT EXECUTED
    );                                                                
  }                                                                   
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );      
  #endif                                                              
}                                                                     
a00070c8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00070cc:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
        "gxx_wrappers: mutex init failed %s (%d)\n",                  
        rtems_status_text(status),                                    
        status                                                        
      );                                                              
    #endif                                                            
    _Internal_error_Occurred(                                         
a00070d0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00070d4:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00070d8:	e3a02016 	mov	r2, #22                                       <== NOT EXECUTED
a00070dc:	eb001316 	bl	a000bd3c <_Internal_error_Occurred>            <== NOT EXECUTED
                                                                      

a00070e4 <rtems_gxx_mutex_lock>: #ifdef DEBUG_GXX_WRAPPERS printk( "gxx_wrappers: lock mutex=%X\n", *mutex ); #endif status = rtems_semaphore_obtain(
a00070e4:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
    printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );      
  #endif                                                              
}                                                                     
                                                                      
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)                   
{                                                                     
a00070e8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: lock mutex=%X\n", *mutex );                
  #endif                                                              
                                                                      
  status = rtems_semaphore_obtain(                                    
a00070ec:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a00070f0:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a00070f4:	eb000d85 	bl	a000a710 <rtems_semaphore_obtain>              <== NOT EXECUTED
    *(rtems_id *)mutex,                                               
    RTEMS_WAIT,                                                       
    RTEMS_NO_TIMEOUT                                                  
  );                                                                  
  if ( status == RTEMS_SUCCESSFUL )                                   
a00070f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return 0;                                                         
  return -1;                                                          
}                                                                     
a00070fc:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0007100:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000711c <rtems_gxx_mutex_trylock>: int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex) {
a000711c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );             
  #endif                                                              
                                                                      
  status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
a0007120:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0007124:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0007128:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a000712c:	eb000d77 	bl	a000a710 <rtems_semaphore_obtain>              <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL )                                   
a0007130:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return 0;                                                         
  return -1;                                                          
}                                                                     
a0007134:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0007138:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000713c <rtems_gxx_mutex_unlock>: int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex) {
a000713c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: unlock mutex=%X\n", *mutex );              
  #endif                                                              
                                                                      
  status = rtems_semaphore_release( *(rtems_id *)mutex );             
a0007140:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a0007144:	eb000dba 	bl	a000a834 <rtems_semaphore_release>             <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL )                                   
a0007148:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return 0;                                                         
  return -1;                                                          
}                                                                     
a000714c:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0007150:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0006ef4 <rtems_gxx_once>: /* uncomment this if you need to debug this interface */ /*#define DEBUG_GXX_WRAPPERS 1*/ int rtems_gxx_once(__gthread_once_t *once, void (*func) (void)) {
a0006ef4:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );        
  #endif                                                              
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
a0006ef8:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
                                                                      
/* uncomment this if you need to debug this interface */              
/*#define DEBUG_GXX_WRAPPERS 1*/                                      
                                                                      
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))       
{                                                                     
a0006efc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0006f00:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );        
  #endif                                                              
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
a0006f04:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
/* uncomment this if you need to debug this interface */              
/*#define DEBUG_GXX_WRAPPERS 1*/                                      
                                                                      
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))       
{                                                                     
a0006f08:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  #ifdef DEBUG_GXX_WRAPPERS                                           
    printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );        
  #endif                                                              
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
a0006f0c:	0a000002 	beq	a0006f1c <rtems_gxx_once+0x28>                <== NOT EXECUTED
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
    if ( o == 0 )                                                     
      (*func)();                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
a0006f10:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006f14:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0006f18:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
    rtems_mode saveMode;                                              
    __gthread_once_t o;                                               
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
a0006f1c:	e3a00c01 	mov	r0, #256	; 0x100                              <== NOT EXECUTED
a0006f20:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0006f24:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0006f28:	eb000efe 	bl	a000ab28 <rtems_task_mode>                     <== NOT EXECUTED
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
a0006f2c:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  if ( *(volatile __gthread_once_t *)once == 0 ) {                    
    rtems_mode saveMode;                                              
    __gthread_once_t o;                                               
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
a0006f30:	e1a0600d 	mov	r6, sp                                        <== NOT EXECUTED
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
a0006f34:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006f38:	1a000007 	bne	a0006f5c <rtems_gxx_once+0x68>                <== NOT EXECUTED
      *(volatile __gthread_once_t *)once = 1;                         
a0006f3c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0006f40:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
a0006f44:	e3a01c01 	mov	r1, #256	; 0x100                              <== NOT EXECUTED
a0006f48:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0006f4c:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a0006f50:	eb000ef4 	bl	a000ab28 <rtems_task_mode>                     <== NOT EXECUTED
    if ( o == 0 )                                                     
      (*func)();                                                      
a0006f54:	e12fff35 	blx	r5                                            <== NOT EXECUTED
a0006f58:	eaffffec 	b	a0006f10 <rtems_gxx_once+0x1c>                  <== NOT EXECUTED
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
      *(volatile __gthread_once_t *)once = 1;                         
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
a0006f5c:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a0006f60:	e3a01c01 	mov	r1, #256	; 0x100                              <== NOT EXECUTED
a0006f64:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0006f68:	eb000eee 	bl	a000ab28 <rtems_task_mode>                     <== NOT EXECUTED
a0006f6c:	eaffffe7 	b	a0006f10 <rtems_gxx_once+0x1c>                  <== NOT EXECUTED
                                                                      

a0007154 <rtems_gxx_recursive_mutex_init>: void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex) { rtems_gxx_mutex_init(mutex);
a0007154:	eaffffd1 	b	a00070a0 <rtems_gxx_mutex_init>                 <== NOT EXECUTED
                                                                      

a0007158 <rtems_gxx_recursive_mutex_lock>: } int rtems_gxx_recursive_mutex_lock(__gthread_recursive_mutex_t *mutex) { return rtems_gxx_mutex_lock(mutex);
a0007158:	eaffffe1 	b	a00070e4 <rtems_gxx_mutex_lock>                 <== NOT EXECUTED
                                                                      

a000715c <rtems_gxx_recursive_mutex_trylock>: } int rtems_gxx_recursive_mutex_trylock(__gthread_recursive_mutex_t *mutex) { return rtems_gxx_mutex_trylock(mutex);
a000715c:	eaffffee 	b	a000711c <rtems_gxx_mutex_trylock>              <== NOT EXECUTED
                                                                      

a0007160 <rtems_gxx_recursive_mutex_unlock>: } int rtems_gxx_recursive_mutex_unlock(__gthread_recursive_mutex_t *mutex) { return rtems_gxx_mutex_unlock(mutex);
a0007160:	eafffff5 	b	a000713c <rtems_gxx_mutex_unlock>               <== NOT EXECUTED
                                                                      

a0007074 <rtems_gxx_setspecific>: #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) {
a0007074:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0007078:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000707c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
      rtems_task_self()                                               
      );                                                              
  #endif                                                              
                                                                      
  /* register with RTEMS the buffer that will hold the key values */  
  status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
a0007080:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a0007084:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0007088:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000708c:	eb000f1f 	bl	a000ad10 <rtems_task_variable_add>             <== NOT EXECUTED
  if ( status == RTEMS_SUCCESSFUL ) {                                 
a0007090:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    /* now let's set the proper value */                              
    key->val =  (void *)ptr;                                          
a0007094:	05845000 	streq	r5, [r4]                                    <== NOT EXECUTED
    return 0;                                                         
  }                                                                   
  return -1;                                                          
a0007098:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
}                                                                     
a000709c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000b65c <rtems_heap_allocate_aligned_with_boundary>: size_t size, uintptr_t alignment, uintptr_t boundary ) { if (
a000b65c:	e59f3048 	ldr	r3, [pc, #72]	; a000b6ac <rtems_heap_allocate_aligned_with_boundary+0x50><== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000b660:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if (                                                                
a000b664:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000b668:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a000b66c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  if (                                                                
a000b670:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
a000b674:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  if (                                                                
a000b678:	0a000007 	beq	a000b69c <rtems_heap_allocate_aligned_with_boundary+0x40><== NOT EXECUTED
      && !malloc_is_system_state_OK()                                 
  ) {                                                                 
    return NULL;                                                      
  }                                                                   
                                                                      
  malloc_deferred_frees_process();                                    
a000b67c:	ebfffba8 	bl	a000a524 <malloc_deferred_frees_process>       <== NOT EXECUTED
                                                                      
  /* FIXME: Statistics, boundary checks */                            
                                                                      
  return _Protected_heap_Allocate_aligned_with_boundary(              
a000b680:	e59f3028 	ldr	r3, [pc, #40]	; a000b6b0 <rtems_heap_allocate_aligned_with_boundary+0x54><== NOT EXECUTED
a000b684:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000b688:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000b68c:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000b690:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment,                                                        
    boundary                                                          
  );                                                                  
}                                                                     
a000b694:	e8bd4070 	pop	{r4, r5, r6, lr}                              <== NOT EXECUTED
                                                                      
  malloc_deferred_frees_process();                                    
                                                                      
  /* FIXME: Statistics, boundary checks */                            
                                                                      
  return _Protected_heap_Allocate_aligned_with_boundary(              
a000b698:	ea0014b6 	b	a0010978 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  if (                                                                
    _System_state_Is_up( _System_state_Get() )                        
      && !malloc_is_system_state_OK()                                 
a000b69c:	ebfffb8c 	bl	a000a4d4 <malloc_is_system_state_OK>           <== NOT EXECUTED
a000b6a0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b6a4:	1afffff4 	bne	a000b67c <rtems_heap_allocate_aligned_with_boundary+0x20><== NOT EXECUTED
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment,                                                        
    boundary                                                          
  );                                                                  
}                                                                     
a000b6a8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000a914 <rtems_interrupt_disable>: static inline uint32_t arm_interrupt_disable( void ) { uint32_t arm_switch_reg; uint32_t level; __asm__ volatile (
a000a914:	e10f0000 	mrs	r0, CPSR                                      <== NOT EXECUTED
a000a918:	e3803080 	orr	r3, r0, #128	; 0x80                           <== NOT EXECUTED
a000a91c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
  rtems_interrupt_level previous_level;                               
                                                                      
  _ISR_Disable( previous_level );                                     
                                                                      
  return previous_level;                                              
}                                                                     
a000a920:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a924 <rtems_interrupt_enable>: static inline void arm_interrupt_enable( uint32_t level ) { ARM_SWITCH_REGISTERS; __asm__ volatile (
a000a924:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
void rtems_interrupt_enable(                                          
  rtems_interrupt_level previous_level                                
)                                                                     
{                                                                     
  _ISR_Enable( previous_level );                                      
}                                                                     
a000a928:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a92c <rtems_interrupt_flash>: static inline void arm_interrupt_flash( uint32_t level ) { uint32_t arm_switch_reg; __asm__ volatile (
a000a92c:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a000a930:	e129f000 	msr	CPSR_fc, r0                                   <== NOT EXECUTED
a000a934:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
void rtems_interrupt_flash(                                           
  rtems_interrupt_level previous_level                                
)                                                                     
{                                                                     
  _ISR_Flash( previous_level );                                       
}                                                                     
a000a938:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a93c <rtems_interrupt_is_in_progress>: #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { return _ISR_Is_in_progress();
a000a93c:	e59f300c 	ldr	r3, [pc, #12]	; a000a950 <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED
a000a940:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
}                                                                     
a000a944:	e2500000 	subs	r0, r0, #0                                   <== NOT EXECUTED
a000a948:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
a000a94c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a2f0 <rtems_interrupt_level_attribute>: rtems_attribute rtems_interrupt_level_attribute( uint32_t level ) { return RTEMS_INTERRUPT_LEVEL(level); }
a000a2f0:	e2000080 	and	r0, r0, #128	; 0x80                           <== NOT EXECUTED
a000a2f4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0010dd4 <rtems_io_close>: void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers )
a0010dd4:	e59fc044 	ldr	ip, [pc, #68]	; a0010e20 <rtems_io_close+0x4c><== NOT EXECUTED
rtems_status_code rtems_io_close(                                     
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010dd8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010ddc:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
rtems_status_code rtems_io_close(                                     
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010de0:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010de4:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
a0010de8:	9a000008 	bls	a0010e10 <rtems_io_close+0x3c>                <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  callout = _IO_Driver_address_table[major].close_entry;              
a0010dec:	e59fc030 	ldr	ip, [pc, #48]	; a0010e24 <rtems_io_close+0x50><== NOT EXECUTED
a0010df0:	e3a04018 	mov	r4, #24                                       <== NOT EXECUTED
a0010df4:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0010df8:	e023c394 	mla	r3, r4, r3, ip                                <== NOT EXECUTED
a0010dfc:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010e00:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010e04:	0a000003 	beq	a0010e18 <rtems_io_close+0x44>                <== NOT EXECUTED
a0010e08:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0010e0c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
    return RTEMS_INVALID_NUMBER;                                      
a0010e10:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010e14:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  callout = _IO_Driver_address_table[major].close_entry;              
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010e18:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
}                                                                     
a0010e1c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0010e28 <rtems_io_control>: void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers )
a0010e28:	e59fc044 	ldr	ip, [pc, #68]	; a0010e74 <rtems_io_control+0x4c><== NOT EXECUTED
rtems_status_code rtems_io_control(                                   
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010e2c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010e30:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
rtems_status_code rtems_io_control(                                   
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010e34:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010e38:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
a0010e3c:	9a000008 	bls	a0010e64 <rtems_io_control+0x3c>              <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  callout = _IO_Driver_address_table[major].control_entry;            
a0010e40:	e59fc030 	ldr	ip, [pc, #48]	; a0010e78 <rtems_io_control+0x50><== NOT EXECUTED
a0010e44:	e3a04018 	mov	r4, #24                                       <== NOT EXECUTED
a0010e48:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0010e4c:	e023c394 	mla	r3, r4, r3, ip                                <== NOT EXECUTED
a0010e50:	e5933014 	ldr	r3, [r3, #20]                                 <== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010e54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010e58:	0a000003 	beq	a0010e6c <rtems_io_control+0x44>              <== NOT EXECUTED
a0010e5c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0010e60:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
    return RTEMS_INVALID_NUMBER;                                      
a0010e64:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010e68:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  callout = _IO_Driver_address_table[major].control_entry;            
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010e6c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
}                                                                     
a0010e70:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0006000 <rtems_io_lookup_name>: rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) {
a0006000:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0006004:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0006008:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000600c:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  IMFS_jnode_t                      *the_jnode;                       
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
  rtems_filesystem_node_types_t      node_type;                       
                                                                      
  result = rtems_filesystem_evaluate_path(                            
a0006010:	eb00301c 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a0006014:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0006018:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000601c:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
a0006020:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0006024:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006028:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000602c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0006030:	eb000090 	bl	a0006278 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
      name, strlen( name ), 0x00, &loc, true );                       
  the_jnode = loc.node_access;                                        
                                                                      
  node_type = (*loc.ops->node_type_h)( &loc );                        
a0006034:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
  IMFS_jnode_t                      *the_jnode;                       
  rtems_filesystem_location_info_t   loc;                             
  int                                result;                          
  rtems_filesystem_node_types_t      node_type;                       
                                                                      
  result = rtems_filesystem_evaluate_path(                            
a0006038:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
      name, strlen( name ), 0x00, &loc, true );                       
  the_jnode = loc.node_access;                                        
                                                                      
  node_type = (*loc.ops->node_type_h)( &loc );                        
a000603c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006040:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
  int                                result;                          
  rtems_filesystem_node_types_t      node_type;                       
                                                                      
  result = rtems_filesystem_evaluate_path(                            
      name, strlen( name ), 0x00, &loc, true );                       
  the_jnode = loc.node_access;                                        
a0006044:	e59d8004 	ldr	r8, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  node_type = (*loc.ops->node_type_h)( &loc );                        
a0006048:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {      
a000604c:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0006050:	03500002 	cmpeq	r0, #2                                      <== NOT EXECUTED
a0006054:	03a07000 	moveq	r7, #0                                      <== NOT EXECUTED
a0006058:	13a07001 	movne	r7, #1                                      <== NOT EXECUTED
a000605c:	0a000004 	beq	a0006074 <rtems_io_lookup_name+0x74>          <== NOT EXECUTED
    rtems_filesystem_freenode( &loc );                                
a0006060:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0006064:	eb0000bd 	bl	a0006360 <rtems_filesystem_freenode>           <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
a0006068:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
  device_info->minor              = the_jnode->info.device.minor;     
                                                                      
  rtems_filesystem_freenode( &loc );                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000606c:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0006070:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {      
    rtems_filesystem_freenode( &loc );                                
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  device_info->device_name        = (char *) name;                    
a0006074:	e5865000 	str	r5, [r6]                                      <== NOT EXECUTED
  device_info->device_name_length = strlen( name );                   
a0006078:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000607c:	eb003001 	bl	a0012088 <strlen>                              <== NOT EXECUTED
a0006080:	e5860004 	str	r0, [r6, #4]                                  <== NOT EXECUTED
  device_info->major              = the_jnode->info.device.major;     
a0006084:	e5983050 	ldr	r3, [r8, #80]	; 0x50                          <== NOT EXECUTED
  device_info->minor              = the_jnode->info.device.minor;     
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0006088:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  device_info->device_name        = (char *) name;                    
  device_info->device_name_length = strlen( name );                   
  device_info->major              = the_jnode->info.device.major;     
a000608c:	e5863008 	str	r3, [r6, #8]                                  <== NOT EXECUTED
  device_info->minor              = the_jnode->info.device.minor;     
a0006090:	e5983054 	ldr	r3, [r8, #84]	; 0x54                          <== NOT EXECUTED
a0006094:	e586300c 	str	r3, [r6, #12]                                 <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0006098:	eb0000b0 	bl	a0006360 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a000609c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00060a0:	eafffff1 	b	a000606c <rtems_io_lookup_name+0x6c>            <== NOT EXECUTED
                                                                      

a0010e7c <rtems_io_open>: void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers )
a0010e7c:	e59fc044 	ldr	ip, [pc, #68]	; a0010ec8 <rtems_io_open+0x4c> <== NOT EXECUTED
rtems_status_code rtems_io_open(                                      
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010e80:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010e84:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
rtems_status_code rtems_io_open(                                      
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010e88:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010e8c:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
a0010e90:	9a000008 	bls	a0010eb8 <rtems_io_open+0x3c>                 <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  callout = _IO_Driver_address_table[major].open_entry;               
a0010e94:	e59fc030 	ldr	ip, [pc, #48]	; a0010ecc <rtems_io_open+0x50> <== NOT EXECUTED
a0010e98:	e3a04018 	mov	r4, #24                                       <== NOT EXECUTED
a0010e9c:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0010ea0:	e023c394 	mla	r3, r4, r3, ip                                <== NOT EXECUTED
a0010ea4:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010ea8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010eac:	0a000003 	beq	a0010ec0 <rtems_io_open+0x44>                 <== NOT EXECUTED
a0010eb0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0010eb4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
    return RTEMS_INVALID_NUMBER;                                      
a0010eb8:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010ebc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  callout = _IO_Driver_address_table[major].open_entry;               
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010ec0:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
}                                                                     
a0010ec4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0010ed0 <rtems_io_read>: void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers )
a0010ed0:	e59fc044 	ldr	ip, [pc, #68]	; a0010f1c <rtems_io_read+0x4c> <== NOT EXECUTED
rtems_status_code rtems_io_read(                                      
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010ed4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010ed8:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
rtems_status_code rtems_io_read(                                      
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010edc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010ee0:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
a0010ee4:	9a000008 	bls	a0010f0c <rtems_io_read+0x3c>                 <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  callout = _IO_Driver_address_table[major].read_entry;               
a0010ee8:	e59fc030 	ldr	ip, [pc, #48]	; a0010f20 <rtems_io_read+0x50> <== NOT EXECUTED
a0010eec:	e3a04018 	mov	r4, #24                                       <== NOT EXECUTED
a0010ef0:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0010ef4:	e023c394 	mla	r3, r4, r3, ip                                <== NOT EXECUTED
a0010ef8:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010efc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010f00:	0a000003 	beq	a0010f14 <rtems_io_read+0x44>                 <== NOT EXECUTED
a0010f04:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0010f08:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
    return RTEMS_INVALID_NUMBER;                                      
a0010f0c:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010f10:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  callout = _IO_Driver_address_table[major].read_entry;               
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010f14:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
}                                                                     
a0010f18:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000b360 <rtems_io_register_driver>: rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) {
a000b360:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000b364:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
a000b368:	e59f014c 	ldr	r0, [pc, #332]	; a000b4bc <rtems_io_register_driver+0x15c><== NOT EXECUTED
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
a000b36c:	e59f314c 	ldr	r3, [pc, #332]	; a000b4c0 <rtems_io_register_driver+0x160><== NOT EXECUTED
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
a000b370:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a000b374:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  rtems_device_major_number         major,                            
  const rtems_driver_address_table *driver_table,                     
  rtems_device_major_number        *registered_major                  
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
a000b378:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
a000b37c:	1a000033 	bne	a000b450 <rtems_io_register_driver+0xf0>      <== NOT EXECUTED
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( registered_major == NULL )                                     
a000b380:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000b384:	0a000041 	beq	a000b490 <rtems_io_register_driver+0x130>     <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
                                                                      
  if ( driver_table == NULL )                                         
a000b388:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
                                                                      
  if ( registered_major == NULL )                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  /* Set it to an invalid value */                                    
  *registered_major = major_limit;                                    
a000b38c:	e5820000 	str	r0, [r2]                                      <== NOT EXECUTED
                                                                      
  if ( driver_table == NULL )                                         
a000b390:	0a00003e 	beq	a000b490 <rtems_io_register_driver+0x130>     <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b394:	e591c000 	ldr	ip, [r1]                                      <== NOT EXECUTED
a000b398:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000b39c:	0a000038 	beq	a000b484 <rtems_io_register_driver+0x124>     <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( major >= major_limit )                                         
a000b3a0:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
a000b3a4:	9a000027 	bls	a000b448 <rtems_io_register_driver+0xe8>      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000b3a8:	e59f0114 	ldr	r0, [pc, #276]	; a000b4c4 <rtems_io_register_driver+0x164><== NOT EXECUTED
a000b3ac:	e590c000 	ldr	ip, [r0]                                      <== NOT EXECUTED
a000b3b0:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
a000b3b4:	e580c000 	str	ip, [r0]                                      <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( major == 0 ) {                                                 
a000b3b8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000b3bc:	1a000025 	bne	a000b458 <rtems_io_register_driver+0xf8>      <== NOT EXECUTED
                                                                      
static rtems_status_code rtems_io_obtain_major_number(                
  rtems_device_major_number *major                                    
)                                                                     
{                                                                     
  rtems_device_major_number n = _IO_Number_of_drivers;                
a000b3c0:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
a000b3c4:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000b3c8:	0a000032 	beq	a000b498 <rtems_io_register_driver+0x138>     <== NOT EXECUTED
a000b3cc:	e59fe0f4 	ldr	lr, [pc, #244]	; a000b4c8 <rtems_io_register_driver+0x168><== NOT EXECUTED
a000b3d0:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
a000b3d4:	ea000003 	b	a000b3e8 <rtems_io_register_driver+0x88>        <== NOT EXECUTED
a000b3d8:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
a000b3dc:	e15c0004 	cmp	ip, r4                                        <== NOT EXECUTED
a000b3e0:	e2833018 	add	r3, r3, #24                                   <== NOT EXECUTED
a000b3e4:	9a000005 	bls	a000b400 <rtems_io_register_driver+0xa0>      <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b3e8:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000b3ec:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b3f0:	1afffff8 	bne	a000b3d8 <rtems_io_register_driver+0x78>      <== NOT EXECUTED
a000b3f4:	e5930004 	ldr	r0, [r3, #4]                                  <== NOT EXECUTED
a000b3f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b3fc:	1afffff5 	bne	a000b3d8 <rtems_io_register_driver+0x78>      <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
                                                                      
  if ( m != n )                                                       
a000b400:	e15c0004 	cmp	ip, r4                                        <== NOT EXECUTED
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
a000b404:	e5824000 	str	r4, [r2]                                      <== NOT EXECUTED
                                                                      
  if ( m != n )                                                       
a000b408:	0a000023 	beq	a000b49c <rtems_io_register_driver+0x13c>     <== NOT EXECUTED
a000b40c:	e3a0c018 	mov	ip, #24                                       <== NOT EXECUTED
a000b410:	e00c0c94 	mul	ip, r4, ip                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
a000b414:	e59e5000 	ldr	r5, [lr]                                      <== NOT EXECUTED
a000b418:	e1a0e001 	mov	lr, r1                                        <== NOT EXECUTED
a000b41c:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000b420:	e085c00c 	add	ip, r5, ip                                    <== NOT EXECUTED
a000b424:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000b428:	e89e0003 	ldm	lr, {r0, r1}                                  <== NOT EXECUTED
a000b42c:	e88c0003 	stm	ip, {r0, r1}                                  <== NOT EXECUTED
                                                                      
  _Thread_Enable_dispatch();                                          
a000b430:	eb00079e 	bl	a000d2b0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
a000b434:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000b438:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b43c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
}                                                                     
a000b440:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
a000b444:	ea001f09 	b	a0013070 <rtems_io_initialize>                  <== NOT EXECUTED
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( major >= major_limit )                                         
    return RTEMS_INVALID_NUMBER;                                      
a000b448:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
  _IO_Driver_address_table [major] = *driver_table;                   
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
}                                                                     
a000b44c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
    return RTEMS_CALLED_FROM_ISR;                                     
a000b450:	e3a00012 	mov	r0, #18                                       <== NOT EXECUTED
a000b454:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
a000b458:	e59fe068 	ldr	lr, [pc, #104]	; a000b4c8 <rtems_io_register_driver+0x168><== NOT EXECUTED
a000b45c:	e3a0c018 	mov	ip, #24                                       <== NOT EXECUTED
a000b460:	e00c0c94 	mul	ip, r4, ip                                    <== NOT EXECUTED
a000b464:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b468:	e793000c 	ldr	r0, [r3, ip]                                  <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
a000b46c:	e083300c 	add	r3, r3, ip                                    <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b470:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b474:	0a00000b 	beq	a000b4a8 <rtems_io_register_driver+0x148>     <== NOT EXECUTED
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
                                                                      
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
a000b478:	eb00078c 	bl	a000d2b0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_RESOURCE_IN_USE;                                   
a000b47c:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
a000b480:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b484:	e591c004 	ldr	ip, [r1, #4]                                  <== NOT EXECUTED
a000b488:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
a000b48c:	1affffc3 	bne	a000b3a0 <rtems_io_register_driver+0x40>      <== NOT EXECUTED
                                                                      
  if ( driver_table == NULL )                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( rtems_io_is_empty_table( driver_table ) )                      
    return RTEMS_INVALID_ADDRESS;                                     
a000b490:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000b494:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
a000b498:	e5824000 	str	r4, [r2]                                      <== NOT EXECUTED
                                                                      
  if ( major == 0 ) {                                                 
    rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
      _Thread_Enable_dispatch();                                      
a000b49c:	eb000783 	bl	a000d2b0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  *major = m;                                                         
                                                                      
  if ( m != n )                                                       
    return RTEMS_SUCCESSFUL;                                          
                                                                      
  return RTEMS_TOO_MANY;                                              
a000b4a0:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
  if ( major == 0 ) {                                                 
    rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
                                                                      
    if ( sc != RTEMS_SUCCESSFUL ) {                                   
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
a000b4a4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
static inline bool rtems_io_is_empty_table(                           
  const rtems_driver_address_table *table                             
)                                                                     
{                                                                     
  return table->initialization_entry == NULL && table->open_entry == NULL;
a000b4a8:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a000b4ac:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b4b0:	1afffff0 	bne	a000b478 <rtems_io_register_driver+0x118>     <== NOT EXECUTED
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
      return RTEMS_RESOURCE_IN_USE;                                   
    }                                                                 
                                                                      
    *registered_major = major;                                        
a000b4b4:	e5824000 	str	r4, [r2]                                      <== NOT EXECUTED
a000b4b8:	eaffffd5 	b	a000b414 <rtems_io_register_driver+0xb4>        <== NOT EXECUTED
                                                                      

a000b4cc <rtems_io_unregister_driver>: rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( rtems_interrupt_is_in_progress() )
a000b4cc:	e59f3064 	ldr	r3, [pc, #100]	; a000b538 <rtems_io_unregister_driver+0x6c><== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_io_unregister_driver(                         
  rtems_device_major_number major                                     
)                                                                     
{                                                                     
a000b4d0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  if ( rtems_interrupt_is_in_progress() )                             
a000b4d4:	e5934000 	ldr	r4, [r3]                                      <== NOT EXECUTED
a000b4d8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000b4dc:	1a000013 	bne	a000b530 <rtems_io_unregister_driver+0x64>    <== NOT EXECUTED
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( major < _IO_Number_of_drivers ) {                              
a000b4e0:	e59f3054 	ldr	r3, [pc, #84]	; a000b53c <rtems_io_unregister_driver+0x70><== NOT EXECUTED
a000b4e4:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000b4e8:	e1530000 	cmp	r3, r0                                        <== NOT EXECUTED
a000b4ec:	8a000001 	bhi	a000b4f8 <rtems_io_unregister_driver+0x2c>    <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
                                                                      
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  return RTEMS_UNSATISFIED;                                           
a000b4f0:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
}                                                                     
a000b4f4:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
a000b4f8:	e59f3040 	ldr	r3, [pc, #64]	; a000b540 <rtems_io_unregister_driver+0x74><== NOT EXECUTED
a000b4fc:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000b500:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000b504:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
  if ( rtems_interrupt_is_in_progress() )                             
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( major < _IO_Number_of_drivers ) {                              
    _Thread_Disable_dispatch();                                       
    memset(                                                           
a000b508:	e59f2034 	ldr	r2, [pc, #52]	; a000b544 <rtems_io_unregister_driver+0x78><== NOT EXECUTED
      &_IO_Driver_address_table[major],                               
a000b50c:	e3a03018 	mov	r3, #24                                       <== NOT EXECUTED
  if ( rtems_interrupt_is_in_progress() )                             
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( major < _IO_Number_of_drivers ) {                              
    _Thread_Disable_dispatch();                                       
    memset(                                                           
a000b510:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000b514:	e592c000 	ldr	ip, [r2]                                      <== NOT EXECUTED
a000b518:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000b51c:	e020c093 	mla	r0, r3, r0, ip                                <== NOT EXECUTED
a000b520:	eb00296e 	bl	a0015ae0 <memset>                              <== NOT EXECUTED
      &_IO_Driver_address_table[major],                               
      0,                                                              
      sizeof( rtems_driver_address_table )                            
    );                                                                
    _Thread_Enable_dispatch();                                        
a000b524:	eb000761 	bl	a000d2b0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
                                                                      
    return RTEMS_SUCCESSFUL;                                          
a000b528:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b52c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
rtems_status_code rtems_io_unregister_driver(                         
  rtems_device_major_number major                                     
)                                                                     
{                                                                     
  if ( rtems_interrupt_is_in_progress() )                             
    return RTEMS_CALLED_FROM_ISR;                                     
a000b530:	e3a00012 	mov	r0, #18                                       <== NOT EXECUTED
a000b534:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0010f24 <rtems_io_write>: void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers )
a0010f24:	e59fc044 	ldr	ip, [pc, #68]	; a0010f70 <rtems_io_write+0x4c><== NOT EXECUTED
rtems_status_code rtems_io_write(                                     
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010f28:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010f2c:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
rtems_status_code rtems_io_write(                                     
  rtems_device_major_number  major,                                   
  rtems_device_minor_number  minor,                                   
  void                      *argument                                 
)                                                                     
{                                                                     
a0010f30:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
a0010f34:	e15c0000 	cmp	ip, r0                                        <== NOT EXECUTED
a0010f38:	9a000008 	bls	a0010f60 <rtems_io_write+0x3c>                <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  callout = _IO_Driver_address_table[major].write_entry;              
a0010f3c:	e59fc030 	ldr	ip, [pc, #48]	; a0010f74 <rtems_io_write+0x50><== NOT EXECUTED
a0010f40:	e3a04018 	mov	r4, #24                                       <== NOT EXECUTED
a0010f44:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a0010f48:	e023c394 	mla	r3, r4, r3, ip                                <== NOT EXECUTED
a0010f4c:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010f50:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010f54:	0a000003 	beq	a0010f68 <rtems_io_write+0x44>                <== NOT EXECUTED
a0010f58:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0010f5c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_device_driver_entry callout;                                  
                                                                      
  if ( major >= _IO_Number_of_drivers )                               
    return RTEMS_INVALID_NUMBER;                                      
a0010f60:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010f64:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  callout = _IO_Driver_address_table[major].write_entry;              
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
a0010f68:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
}                                                                     
a0010f6c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000c8ac <rtems_iterate_over_all_threads>: #include <rtems/system.h> #include <rtems/score/thread.h> void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) {
a000c8ac:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
a000c8b0:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a000c8b4:	0a000016 	beq	a000c914 <rtems_iterate_over_all_threads+0x68><== NOT EXECUTED
a000c8b8:	e59f7058 	ldr	r7, [pc, #88]	; a000c918 <rtems_iterate_over_all_threads+0x6c><== NOT EXECUTED
#endif                                                                
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/thread.h>                                       
                                                                      
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 
a000c8bc:	e287800c 	add	r8, r7, #12                                   <== NOT EXECUTED
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
a000c8c0:	e5b73004 	ldr	r3, [r7, #4]!                                 <== NOT EXECUTED
a000c8c4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c8c8:	0a00000f 	beq	a000c90c <rtems_iterate_over_all_threads+0x60><== NOT EXECUTED
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
a000c8cc:	e5935004 	ldr	r5, [r3, #4]                                  <== NOT EXECUTED
    if ( !information )                                               
a000c8d0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000c8d4:	0a00000c 	beq	a000c90c <rtems_iterate_over_all_threads+0x60><== NOT EXECUTED
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
a000c8d8:	e1d521b0 	ldrh	r2, [r5, #16]                                <== NOT EXECUTED
a000c8dc:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000c8e0:	0a000009 	beq	a000c90c <rtems_iterate_over_all_threads+0x60><== NOT EXECUTED
a000c8e4:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
      the_thread = (Thread_Control *)information->local_table[ i ];   
a000c8e8:	e595301c 	ldr	r3, [r5, #28]                                 <== NOT EXECUTED
a000c8ec:	e7930104 	ldr	r0, [r3, r4, lsl #2]                          <== NOT EXECUTED
                                                                      
      if ( !the_thread )                                              
a000c8f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000c8f4:	0a000001 	beq	a000c900 <rtems_iterate_over_all_threads+0x54><== NOT EXECUTED
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
a000c8f8:	e12fff36 	blx	r6                                            <== NOT EXECUTED
a000c8fc:	e1d521b0 	ldrh	r2, [r5, #16]                                <== NOT EXECUTED
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
a000c900:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
a000c904:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000c908:	2afffff6 	bcs	a000c8e8 <rtems_iterate_over_all_threads+0x3c><== NOT EXECUTED
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
a000c90c:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
a000c910:	1affffea 	bne	a000c8c0 <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
a000c914:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a000e50c <rtems_libio_fcntl_flags>: }; uint32_t rtems_libio_fcntl_flags( uint32_t fcntl_flags ) {
a000e50c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
   * Access mode is a small integer                                   
   */                                                                 
                                                                      
  access_modes = fcntl_flags & O_ACCMODE;                             
  fcntl_flags &= ~O_ACCMODE;                                          
  flags = rtems_assoc_local_by_remote( access_modes_assoc, access_modes );
a000e510:	e59f4024 	ldr	r4, [pc, #36]	; a000e53c <rtems_libio_fcntl_flags+0x30><== NOT EXECUTED
};                                                                    
                                                                      
uint32_t   rtems_libio_fcntl_flags(                                   
  uint32_t   fcntl_flags                                              
)                                                                     
{                                                                     
a000e514:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   * Access mode is a small integer                                   
   */                                                                 
                                                                      
  access_modes = fcntl_flags & O_ACCMODE;                             
  fcntl_flags &= ~O_ACCMODE;                                          
  flags = rtems_assoc_local_by_remote( access_modes_assoc, access_modes );
a000e518:	e2001003 	and	r1, r0, #3                                    <== NOT EXECUTED
a000e51c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e520:	eb0009a7 	bl	a0010bc4 <rtems_assoc_local_by_remote>         <== NOT EXECUTED
  /*                                                                  
   * Everything else is single bits                                   
   */                                                                 
                                                                      
  flags |=                                                            
     rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags);
a000e524:	e3c51003 	bic	r1, r5, #3                                    <== NOT EXECUTED
   * Access mode is a small integer                                   
   */                                                                 
                                                                      
  access_modes = fcntl_flags & O_ACCMODE;                             
  fcntl_flags &= ~O_ACCMODE;                                          
  flags = rtems_assoc_local_by_remote( access_modes_assoc, access_modes );
a000e528:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  /*                                                                  
   * Everything else is single bits                                   
   */                                                                 
                                                                      
  flags |=                                                            
     rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags);
a000e52c:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
a000e530:	eb00098e 	bl	a0010b70 <rtems_assoc_local_by_remote_bitfield><== NOT EXECUTED
  return flags;                                                       
}                                                                     
a000e534:	e1800006 	orr	r0, r0, r6                                    <== NOT EXECUTED
a000e538:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a00064c0 <rtems_libio_init>: { rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0)
a00064c0:	e59f30bc 	ldr	r3, [pc, #188]	; a0006584 <rtems_libio_init+0xc4>
 *                                                                    
 *  Called by BSP startup code to initialize the libio subsystem.     
 */                                                                   
                                                                      
void rtems_libio_init( void )                                         
{                                                                     
a00064c4:	e92d4010 	push	{r4, lr}                                     
    rtems_status_code rc;                                             
    uint32_t i;                                                       
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
a00064c8:	e5934000 	ldr	r4, [r3]                                      
 *                                                                    
 *  Called by BSP startup code to initialize the libio subsystem.     
 */                                                                   
                                                                      
void rtems_libio_init( void )                                         
{                                                                     
a00064cc:	e24dd004 	sub	sp, sp, #4                                    
    rtems_status_code rc;                                             
    uint32_t i;                                                       
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
a00064d0:	e3540000 	cmp	r4, #0                                        
a00064d4:	0a000017 	beq	a0006538 <rtems_libio_init+0x78>              
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
a00064d8:	e1a00004 	mov	r0, r4                                        
a00064dc:	e3a01038 	mov	r1, #56	; 0x38                                
a00064e0:	ebffff35 	bl	a00061bc <calloc>                              
a00064e4:	e59f309c 	ldr	r3, [pc, #156]	; a0006588 <rtems_libio_init+0xc8>
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
a00064e8:	e3500000 	cmp	r0, #0                                        
    uint32_t i;                                                       
    rtems_libio_t *iop;                                               
                                                                      
    if (rtems_libio_number_iops > 0)                                  
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
a00064ec:	e1a02000 	mov	r2, r0                                        
a00064f0:	e5830000 	str	r0, [r3]                                      
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
a00064f4:	0a000020 	beq	a000657c <rtems_libio_init+0xbc>              
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
a00064f8:	e59f308c 	ldr	r3, [pc, #140]	; a000658c <rtems_libio_init+0xcc>
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
a00064fc:	e3540001 	cmp	r4, #1                                        
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
a0006500:	e5830000 	str	r0, [r3]                                      
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
a0006504:	9a000009 	bls	a0006530 <rtems_libio_init+0x70>              
 *  rtems_libio_init                                                  
 *                                                                    
 *  Called by BSP startup code to initialize the libio subsystem.     
 */                                                                   
                                                                      
void rtems_libio_init( void )                                         
a0006508:	e2803038 	add	r3, r0, #56	; 0x38                            
a000650c:	e3a02001 	mov	r2, #1                                        
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
          iop->data1 = iop + 1;                                       
a0006510:	e2822001 	add	r2, r2, #1                                    
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
a0006514:	e1520004 	cmp	r2, r4                                        
          iop->data1 = iop + 1;                                       
a0006518:	e5033004 	str	r3, [r3, #-4]                                 
a000651c:	e2833038 	add	r3, r3, #56	; 0x38                            
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
a0006520:	1afffffa 	bne	a0006510 <rtems_libio_init+0x50>              
 *  rtems_libio_init                                                  
 *                                                                    
 *  Called by BSP startup code to initialize the libio subsystem.     
 */                                                                   
                                                                      
void rtems_libio_init( void )                                         
a0006524:	e2422001 	sub	r2, r2, #1                                    
a0006528:	e3a03038 	mov	r3, #56	; 0x38                                
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
a000652c:	e0220293 	mla	r2, r3, r2, r0                                
          iop->data1 = iop + 1;                                       
        iop->data1 = NULL;                                            
a0006530:	e3a03000 	mov	r3, #0                                        
a0006534:	e5823034 	str	r3, [r2, #52]	; 0x34                          
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
a0006538:	e59fc050 	ldr	ip, [pc, #80]	; a0006590 <rtems_libio_init+0xd0>
a000653c:	e59f0050 	ldr	r0, [pc, #80]	; a0006594 <rtems_libio_init+0xd4>
a0006540:	e3a01001 	mov	r1, #1                                        
a0006544:	e3a02054 	mov	r2, #84	; 0x54                                
a0006548:	e3a03000 	mov	r3, #0                                        
a000654c:	e58dc000 	str	ip, [sp]                                      
a0006550:	eb000cab 	bl	a0009804 <rtems_semaphore_create>              
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
a0006554:	e3500000 	cmp	r0, #0                                        
a0006558:	1a000006 	bne	a0006578 <rtems_libio_init+0xb8>              
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  if (rtems_fs_init_helper)                                           
a000655c:	e59f3034 	ldr	r3, [pc, #52]	; a0006598 <rtems_libio_init+0xd8>
a0006560:	e5933000 	ldr	r3, [r3]                                      
a0006564:	e3530000 	cmp	r3, #0                                        
a0006568:	0a000000 	beq	a0006570 <rtems_libio_init+0xb0>              
     (* rtems_fs_init_helper)();                                      
a000656c:	e12fff33 	blx	r3                                            
}                                                                     
a0006570:	e28dd004 	add	sp, sp, #4                                    
a0006574:	e8bd8010 	pop	{r4, pc}                                      
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
    rtems_fatal_error_occurred( rc );                                 
a0006578:	eb000ee2 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
    if (rtems_libio_number_iops > 0)                                  
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
a000657c:	e280001a 	add	r0, r0, #26                                   <== NOT EXECUTED
a0006580:	eb000ee0 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a000e78c <rtems_libio_is_file_open>: */ int rtems_libio_is_file_open( void *node_access ) {
a000e78c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000e790:	e59f5084 	ldr	r5, [pc, #132]	; a000e81c <rtems_libio_is_file_open+0x90><== NOT EXECUTED
a000e794:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000e798:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000e79c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000e7a0:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e7a4:	ebffecb0 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
 for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e7a8:	e59f3070 	ldr	r3, [pc, #112]	; a000e820 <rtems_libio_is_file_open+0x94><== NOT EXECUTED
a000e7ac:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000e7b0:	e59f306c 	ldr	r3, [pc, #108]	; a000e824 <rtems_libio_is_file_open+0x98><== NOT EXECUTED
a000e7b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e7b8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int rtems_libio_is_file_open(                                         
  void         *node_access                                           
)                                                                     
{                                                                     
  rtems_libio_t     *iop;                                             
  int                result=0;                                        
a000e7bc:	01a04000 	moveq	r4, r0                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
 for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e7c0:	0a00000c 	beq	a000e7f8 <rtems_libio_is_file_open+0x6c>      <== NOT EXECUTED
a000e7c4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000e7c8:	ea000000 	b	a000e7d0 <rtems_libio_is_file_open+0x44>        <== NOT EXECUTED
a000e7cc:	e2833038 	add	r3, r3, #56	; 0x38                            <== NOT EXECUTED
    if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {                       
a000e7d0:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
 for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e7d4:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {                       
a000e7d8:	e3110c01 	tst	r1, #256	; 0x100                              <== NOT EXECUTED
a000e7dc:	0a000002 	beq	a000e7ec <rtems_libio_is_file_open+0x60>      <== NOT EXECUTED
       /*                                                             
        *  Check if this node is under the file system that we        
        *  are trying to dismount.                                    
        */                                                            
                                                                      
       if ( iop->pathinfo.node_access == node_access ) {              
a000e7e0:	e5931018 	ldr	r1, [r3, #24]                                 <== NOT EXECUTED
a000e7e4:	e1510004 	cmp	r1, r4                                        <== NOT EXECUTED
a000e7e8:	0a000006 	beq	a000e808 <rtems_libio_is_file_open+0x7c>      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
 for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e7ec:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
a000e7f0:	3afffff5 	bcc	a000e7cc <rtems_libio_is_file_open+0x40>      <== NOT EXECUTED
int rtems_libio_is_file_open(                                         
  void         *node_access                                           
)                                                                     
{                                                                     
  rtems_libio_t     *iop;                                             
  int                result=0;                                        
a000e7f4:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000e7f8:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e7fc:	ebffece3 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_libio_unlock();                                               
                                                                      
  return result;                                                      
}                                                                     
a000e800:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e804:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
        *  Check if this node is under the file system that we        
        *  are trying to dismount.                                    
        */                                                            
                                                                      
       if ( iop->pathinfo.node_access == node_access ) {              
          result = 1;                                                 
a000e808:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
a000e80c:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e810:	ebffecde 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_libio_unlock();                                               
                                                                      
  return result;                                                      
}                                                                     
a000e814:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e818:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000e6f0 <rtems_libio_is_open_files_in_fs>: */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) {
a000e6f0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000e6f4:	e59f5084 	ldr	r5, [pc, #132]	; a000e780 <rtems_libio_is_open_files_in_fs+0x90><== NOT EXECUTED
a000e6f8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000e6fc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000e700:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000e704:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e708:	ebffecd7 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
  for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e70c:	e59f3070 	ldr	r3, [pc, #112]	; a000e784 <rtems_libio_is_open_files_in_fs+0x94><== NOT EXECUTED
a000e710:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000e714:	e59f306c 	ldr	r3, [pc, #108]	; a000e788 <rtems_libio_is_open_files_in_fs+0x98><== NOT EXECUTED
a000e718:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000e71c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
int rtems_libio_is_open_files_in_fs(                                  
  rtems_filesystem_mount_table_entry_t * fs_mt_entry                  
)                                                                     
{                                                                     
  rtems_libio_t     *iop;                                             
  int                result = 0;                                      
a000e720:	01a04000 	moveq	r4, r0                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
  for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e724:	0a00000c 	beq	a000e75c <rtems_libio_is_open_files_in_fs+0x6c><== NOT EXECUTED
a000e728:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000e72c:	ea000000 	b	a000e734 <rtems_libio_is_open_files_in_fs+0x44> <== NOT EXECUTED
a000e730:	e2833038 	add	r3, r3, #56	; 0x38                            <== NOT EXECUTED
                                                                      
    if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {                       
a000e734:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
  for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e738:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
    if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {                       
a000e73c:	e3110c01 	tst	r1, #256	; 0x100                              <== NOT EXECUTED
a000e740:	0a000002 	beq	a000e750 <rtems_libio_is_open_files_in_fs+0x60><== NOT EXECUTED
       /*                                                             
        *  Check if this node is under the file system that we        
        *  are trying to dismount.                                    
        */                                                            
                                                                      
       if ( iop->pathinfo.mt_entry == fs_mt_entry ) {                 
a000e744:	e5931028 	ldr	r1, [r3, #40]	; 0x28                          <== NOT EXECUTED
a000e748:	e1510004 	cmp	r1, r4                                        <== NOT EXECUTED
a000e74c:	0a000006 	beq	a000e76c <rtems_libio_is_open_files_in_fs+0x7c><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Look for any active file descriptor entry.                      
   */                                                                 
                                                                      
  for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
a000e750:	e1520000 	cmp	r2, r0                                        <== NOT EXECUTED
a000e754:	3afffff5 	bcc	a000e730 <rtems_libio_is_open_files_in_fs+0x40><== NOT EXECUTED
int rtems_libio_is_open_files_in_fs(                                  
  rtems_filesystem_mount_table_entry_t * fs_mt_entry                  
)                                                                     
{                                                                     
  rtems_libio_t     *iop;                                             
  int                result = 0;                                      
a000e758:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000e75c:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e760:	ebffed0a 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_libio_unlock();                                               
                                                                      
  return result;                                                      
}                                                                     
a000e764:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e768:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
        *  Check if this node is under the file system that we        
        *  are trying to dismount.                                    
        */                                                            
                                                                      
       if ( iop->pathinfo.mt_entry == fs_mt_entry ) {                 
          result = 1;                                                 
a000e76c:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
a000e770:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000e774:	ebffed05 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_libio_unlock();                                               
                                                                      
  return result;                                                      
}                                                                     
a000e778:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000e77c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0007808 <rtems_libio_set_private_env>: } } rtems_status_code rtems_libio_set_private_env(void) {
a0007808:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a000780c:	e24dd02c 	sub	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id task_id = rtems_task_self();                               
a0007810:	eb000b80 	bl	a000a618 <rtems_task_self>                     <== NOT EXECUTED
  rtems_filesystem_location_info_t root_loc;                          
  rtems_filesystem_location_info_t current_loc;                       
  rtems_user_env_t *new_env = NULL;                                   
  int rv = 0;                                                         
                                                                      
  rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);       
a0007814:	e28d7018 	add	r7, sp, #24                                   <== NOT EXECUTED
a0007818:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
a000781c:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
}                                                                     
                                                                      
rtems_status_code rtems_libio_set_private_env(void)                   
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id task_id = rtems_task_self();                               
a0007820:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t root_loc;                          
  rtems_filesystem_location_info_t current_loc;                       
  rtems_user_env_t *new_env = NULL;                                   
  int rv = 0;                                                         
                                                                      
  rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);       
a0007824:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0007828:	e59f00fc 	ldr	r0, [pc, #252]	; a000792c <rtems_libio_set_private_env+0x124><== NOT EXECUTED
a000782c:	e1a03007 	mov	r3, r7                                        <== NOT EXECUTED
a0007830:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0007834:	ebfffb22 	bl	a00064c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
  if (rv != 0)                                                        
a0007838:	e250c000 	subs	ip, r0, #0                                   <== NOT EXECUTED
                                                                      
error_1:                                                              
  rtems_filesystem_freenode(&root_loc);                               
                                                                      
error_0:                                                              
  return RTEMS_NO_MEMORY;                                             
a000783c:	13a0001a 	movne	r0, #26                                     <== NOT EXECUTED
  rtems_filesystem_location_info_t current_loc;                       
  rtems_user_env_t *new_env = NULL;                                   
  int rv = 0;                                                         
                                                                      
  rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);       
  if (rv != 0)                                                        
a0007840:	0a000001 	beq	a000784c <rtems_libio_set_private_env+0x44>   <== NOT EXECUTED
error_1:                                                              
  rtems_filesystem_freenode(&root_loc);                               
                                                                      
error_0:                                                              
  return RTEMS_NO_MEMORY;                                             
}                                                                     
a0007844:	e28dd02c 	add	sp, sp, #44	; 0x2c                            <== NOT EXECUTED
a0007848:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
                                                                      
  rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);       
  if (rv != 0)                                                        
    goto error_0;                                                     
                                                                      
  rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);    
a000784c:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
a0007850:	e59f00d4 	ldr	r0, [pc, #212]	; a000792c <rtems_libio_set_private_env+0x124><== NOT EXECUTED
a0007854:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0007858:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a000785c:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a0007860:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0007864:	ebfffb16 	bl	a00064c4 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
  if (rv != 0)                                                        
a0007868:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000786c:	1a00002a 	bne	a000791c <rtems_libio_set_private_env+0x114>  <== NOT EXECUTED
   * Bharath: I'm not sure if the check can be reduced to             
   * if( rtems_current_user_env->task_id != task_id ) {               
   */                                                                 
                                                                      
  if (                                                                
    rtems_current_user_env == &rtems_global_user_env                  
a0007870:	e59f30b8 	ldr	r3, [pc, #184]	; a0007930 <rtems_libio_set_private_env+0x128><== NOT EXECUTED
a0007874:	e5934000 	ldr	r4, [r3]                                      <== NOT EXECUTED
  /*                                                                  
   * Bharath: I'm not sure if the check can be reduced to             
   * if( rtems_current_user_env->task_id != task_id ) {               
   */                                                                 
                                                                      
  if (                                                                
a0007878:	e59f30b4 	ldr	r3, [pc, #180]	; a0007934 <rtems_libio_set_private_env+0x12c><== NOT EXECUTED
a000787c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a0007880:	0a000002 	beq	a0007890 <rtems_libio_set_private_env+0x88>   <== NOT EXECUTED
    rtems_current_user_env == &rtems_global_user_env                  
      || rtems_current_user_env->task_id != task_id                   
a0007884:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a0007888:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a000788c:	0a00000d 	beq	a00078c8 <rtems_libio_set_private_env+0xc0>   <== NOT EXECUTED
  ) {                                                                 
    new_env = malloc(sizeof(rtems_user_env_t));                       
a0007890:	e3a00048 	mov	r0, #72	; 0x48                                <== NOT EXECUTED
a0007894:	ebfffd01 	bl	a0006ca0 <malloc>                              <== NOT EXECUTED
    if (new_env == NULL)                                              
a0007898:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
                                                                      
  if (                                                                
    rtems_current_user_env == &rtems_global_user_env                  
      || rtems_current_user_env->task_id != task_id                   
  ) {                                                                 
    new_env = malloc(sizeof(rtems_user_env_t));                       
a000789c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00078a0:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
    if (new_env == NULL)                                              
a00078a4:	0a00001a 	beq	a0007914 <rtems_libio_set_private_env+0x10c>  <== NOT EXECUTED
                                                                      
    #ifdef HAVE_USERENV_REFCNT                                        
      new_env->refcnt = 1;                                            
    #endif                                                            
                                                                      
    sc = rtems_task_variable_add(                                     
a00078a8:	e59f8080 	ldr	r8, [pc, #128]	; a0007930 <rtems_libio_set_private_env+0x128><== NOT EXECUTED
a00078ac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00078b0:	e59f2080 	ldr	r2, [pc, #128]	; a0007938 <rtems_libio_set_private_env+0x130><== NOT EXECUTED
a00078b4:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a00078b8:	eb000b75 	bl	a000a694 <rtems_task_variable_add>             <== NOT EXECUTED
      RTEMS_SELF,                                                     
      (void*)&rtems_current_user_env,                                 
      (void(*)(void *))free_user_env                                  
    );                                                                
    if (sc != RTEMS_SUCCESSFUL)                                       
a00078bc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00078c0:	1a000011 	bne	a000790c <rtems_libio_set_private_env+0x104>  <== NOT EXECUTED
      goto error_3;                                                   
                                                                      
    rtems_current_user_env = new_env;                                 
a00078c4:	e5884000 	str	r4, [r8]                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Inherit the global values */                                     
  *rtems_current_user_env = rtems_global_user_env;                    
a00078c8:	e59f1064 	ldr	r1, [pc, #100]	; a0007934 <rtems_libio_set_private_env+0x12c><== NOT EXECUTED
a00078cc:	e3a02048 	mov	r2, #72	; 0x48                                <== NOT EXECUTED
a00078d0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00078d4:	eb002936 	bl	a0011db4 <memcpy>                              <== NOT EXECUTED
   * Clone the pathlocs. In contrast to most other code we must _not_ free the
   * original locs because what we are trying to do here is forking off clones.
   * The reason is a pathloc can be allocated by the file system and needs to
   * be freed when deleting the environment.                          
   */                                                                 
  rtems_filesystem_root = root_loc;                                   
a00078d8:	e8b7000f 	ldm	r7!, {r0, r1, r2, r3}                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /* Inherit the global values */                                     
  *rtems_current_user_env = rtems_global_user_env;                    
                                                                      
  rtems_current_user_env->task_id = task_id;                          
a00078dc:	e1a0c004 	mov	ip, r4                                        <== NOT EXECUTED
a00078e0:	e48c6018 	str	r6, [ip], #24                                 <== NOT EXECUTED
   * original locs because what we are trying to do here is forking off clones.
   * The reason is a pathloc can be allocated by the file system and needs to
   * be freed when deleting the environment.                          
   */                                                                 
  rtems_filesystem_root = root_loc;                                   
  rtems_filesystem_current = current_loc;                             
a00078e4:	e2844004 	add	r4, r4, #4                                    <== NOT EXECUTED
   * Clone the pathlocs. In contrast to most other code we must _not_ free the
   * original locs because what we are trying to do here is forking off clones.
   * The reason is a pathloc can be allocated by the file system and needs to
   * be freed when deleting the environment.                          
   */                                                                 
  rtems_filesystem_root = root_loc;                                   
a00078e8:	e5976000 	ldr	r6, [r7]                                      <== NOT EXECUTED
a00078ec:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
  rtems_filesystem_current = current_loc;                             
a00078f0:	e8b5000f 	ldm	r5!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a00078f4:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a00078f8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
   * Clone the pathlocs. In contrast to most other code we must _not_ free the
   * original locs because what we are trying to do here is forking off clones.
   * The reason is a pathloc can be allocated by the file system and needs to
   * be freed when deleting the environment.                          
   */                                                                 
  rtems_filesystem_root = root_loc;                                   
a00078fc:	e58c6000 	str	r6, [ip]                                      <== NOT EXECUTED
  rtems_filesystem_current = current_loc;                             
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0007900:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   * original locs because what we are trying to do here is forking off clones.
   * The reason is a pathloc can be allocated by the file system and needs to
   * be freed when deleting the environment.                          
   */                                                                 
  rtems_filesystem_root = root_loc;                                   
  rtems_filesystem_current = current_loc;                             
a0007904:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0007908:	eaffffcd 	b	a0007844 <rtems_libio_set_private_env+0x3c>     <== NOT EXECUTED
                                                                      
error_3:                                                              
  free(new_env);                                                      
a000790c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007910:	ebfffb2a 	bl	a00065c0 <free>                                <== NOT EXECUTED
                                                                      
error_2:                                                              
  rtems_filesystem_freenode(¤t_loc);                            
a0007914:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007918:	ebfffb23 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
error_1:                                                              
  rtems_filesystem_freenode(&root_loc);                               
a000791c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0007920:	ebfffb21 	bl	a00065ac <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
error_0:                                                              
  return RTEMS_NO_MEMORY;                                             
a0007924:	e3a0001a 	mov	r0, #26                                       <== NOT EXECUTED
a0007928:	eaffffc5 	b	a0007844 <rtems_libio_set_private_env+0x3c>     <== NOT EXECUTED
                                                                      

a000793c <rtems_libio_share_private_env>: * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
a000793c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0007940:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0007944:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_id           current_task_id;                                 
                                                                      
  /*                                                                  
   * get current task id                                              
   */                                                                 
  current_task_id = rtems_task_self();                                
a0007948:	eb000b32 	bl	a000a618 <rtems_task_self>                     <== NOT EXECUTED
  /*                                                                  
   * If this was an attempt to share the task with self,              
   * if somebody wanted to do it... Lets tell them, its shared        
   */                                                                 
                                                                      
  if( task_id == current_task_id )                                    
a000794c:	e1560000 	cmp	r6, r0                                        <== NOT EXECUTED
  rtems_id           current_task_id;                                 
                                                                      
  /*                                                                  
   * get current task id                                              
   */                                                                 
  current_task_id = rtems_task_self();                                
a0007950:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
   * If this was an attempt to share the task with self,              
   * if somebody wanted to do it... Lets tell them, its shared        
   */                                                                 
                                                                      
  if( task_id == current_task_id )                                    
    return RTEMS_SUCCESSFUL;                                          
a0007954:	03a06000 	moveq	r6, #0                                      <== NOT EXECUTED
  /*                                                                  
   * If this was an attempt to share the task with self,              
   * if somebody wanted to do it... Lets tell them, its shared        
   */                                                                 
                                                                      
  if( task_id == current_task_id )                                    
a0007958:	0a00000c 	beq	a0007990 <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
  /*                                                                  
   * Try to get the requested user environment                        
   */                                                                 
  sc = rtems_task_variable_get(                                       
a000795c:	e59f5040 	ldr	r5, [pc, #64]	; a00079a4 <rtems_libio_share_private_env+0x68><== NOT EXECUTED
a0007960:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007964:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0007968:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000796c:	eb000b74 	bl	a000a744 <rtems_task_variable_get>             <== NOT EXECUTED
	 (void*)&shared_user_env );                                          
                                                                      
  /*                                                                  
   * If it was not successful, return the error code                  
   */                                                                 
    if (sc != RTEMS_SUCCESSFUL)                                       
a0007970:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0007974:	1a000005 	bne	a0007990 <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
     * If we have a current environment in place, we need to          
     * free it, since we will be sharing the variable with the        
     * shared_user_env                                                
     */                                                               
                                                                      
  if (rtems_current_user_env->task_id==current_task_id) {             
a0007978:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a000797c:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0007980:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a0007984:	0a000004 	beq	a000799c <rtems_libio_share_private_env+0x60> <== NOT EXECUTED
    rtems_user_env_t  *tmp = rtems_current_user_env;                  
    free_user_env( tmp );                                             
  }                                                                   
                                                                      
  /* the current_user_env is the same pointer that remote env */      
  rtems_current_user_env = shared_user_env;                           
a0007988:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000798c:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT                                            
  rtems_current_user_env->refcnt++;                                   
#endif                                                                
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0007990:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007994:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0007998:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
     * shared_user_env                                                
     */                                                               
                                                                      
  if (rtems_current_user_env->task_id==current_task_id) {             
    rtems_user_env_t  *tmp = rtems_current_user_env;                  
    free_user_env( tmp );                                             
a000799c:	ebffff8b 	bl	a00077d0 <free_user_env>                       <== NOT EXECUTED
a00079a0:	eafffff8 	b	a0007988 <rtems_libio_share_private_env+0x4c>   <== NOT EXECUTED
                                                                      

a000e540 <rtems_libio_to_fcntl_flags>: uint32_t flags ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
a000e540:	e2002006 	and	r2, r0, #6                                    <== NOT EXECUTED
a000e544:	e3520006 	cmp	r2, #6                                        <== NOT EXECUTED
 */                                                                   
                                                                      
uint32_t   rtems_libio_to_fcntl_flags(                                
  uint32_t   flags                                                    
)                                                                     
{                                                                     
a000e548:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  uint32_t   fcntl_flags = 0;                                         
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
    fcntl_flags |= O_RDWR;                                            
a000e54c:	03a00002 	moveq	r0, #2                                      <== NOT EXECUTED
  uint32_t   flags                                                    
)                                                                     
{                                                                     
  uint32_t   fcntl_flags = 0;                                         
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
a000e550:	0a000002 	beq	a000e560 <rtems_libio_to_fcntl_flags+0x20>    <== NOT EXECUTED
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
a000e554:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
    fcntl_flags |= O_RDONLY;                                          
a000e558:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
{                                                                     
  uint32_t   fcntl_flags = 0;                                         
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
a000e55c:	0a000006 	beq	a000e57c <rtems_libio_to_fcntl_flags+0x3c>    <== NOT EXECUTED
    fcntl_flags |= O_RDONLY;                                          
  } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {     
    fcntl_flags |= O_WRONLY;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {     
a000e560:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
    fcntl_flags |= O_NONBLOCK;                                        
a000e564:	13800901 	orrne	r0, r0, #16384	; 0x4000                     <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {         
a000e568:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
    fcntl_flags |= O_APPEND;                                          
a000e56c:	13800008 	orrne	r0, r0, #8                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {         
a000e570:	e3130b01 	tst	r3, #1024	; 0x400                             <== NOT EXECUTED
    fcntl_flags |= O_CREAT;                                           
a000e574:	13800c02 	orrne	r0, r0, #512	; 0x200                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return fcntl_flags;                                                 
}                                                                     
a000e578:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
)                                                                     
{                                                                     
  uint32_t   fcntl_flags = 0;                                         
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
    fcntl_flags |= O_RDWR;                                            
a000e57c:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a000e580:	03a00000 	moveq	r0, #0                                      <== NOT EXECUTED
a000e584:	13a00001 	movne	r0, #1                                      <== NOT EXECUTED
a000e588:	eafffff4 	b	a000e560 <rtems_libio_to_fcntl_flags+0x20>      <== NOT EXECUTED
                                                                      

a000a8b0 <rtems_malloc_statistics_at_free>: * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) {
a000a8b0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
a000a8b4:	e59f3040 	ldr	r3, [pc, #64]	; a000a8fc <rtems_malloc_statistics_at_free+0x4c><== NOT EXECUTED
 *  size and thus we skip updating the statistics.                    
 */                                                                   
static void rtems_malloc_statistics_at_free(                          
  void *pointer                                                       
)                                                                     
{                                                                     
a000a8b8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000a8bc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
a000a8c0:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000a8c4:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a000a8c8:	eb001860 	bl	a0010a50 <_Protected_heap_Get_block_size>      <== NOT EXECUTED
a000a8cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a8d0:	0a000007 	beq	a000a8f4 <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
    MSBUMP(lifetime_freed, size);                                     
a000a8d4:	e59f3024 	ldr	r3, [pc, #36]	; a000a900 <rtems_malloc_statistics_at_free+0x50><== NOT EXECUTED
a000a8d8:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a000a8dc:	e2832024 	add	r2, r3, #36	; 0x24                            <== NOT EXECUTED
a000a8e0:	e8920006 	ldm	r2, {r1, r2}                                  <== NOT EXECUTED
a000a8e4:	e0911000 	adds	r1, r1, r0                                   <== NOT EXECUTED
a000a8e8:	e2a22000 	adc	r2, r2, #0                                    <== NOT EXECUTED
a000a8ec:	e5831024 	str	r1, [r3, #36]	; 0x24                          <== NOT EXECUTED
a000a8f0:	e5832028 	str	r2, [r3, #40]	; 0x28                          <== NOT EXECUTED
  }                                                                   
}                                                                     
a000a8f4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000a8f8:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a001282c <rtems_memalign>: int rtems_memalign( void **pointer, size_t alignment, size_t size ) {
a001282c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
a0012830:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
int rtems_memalign(                                                   
  void   **pointer,                                                   
  size_t   alignment,                                                 
  size_t   size                                                       
)                                                                     
{                                                                     
a0012834:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0012838:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
a001283c:	0a00001b 	beq	a00128b0 <rtems_memalign+0x84>                <== NOT EXECUTED
    return EINVAL;                                                    
                                                                      
  *pointer = NULL;                                                    
a0012840:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0012844:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a0012848:	e59f3070 	ldr	r3, [pc, #112]	; a00128c0 <rtems_memalign+0x94><== NOT EXECUTED
a001284c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0012850:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a0012854:	0a000012 	beq	a00128a4 <rtems_memalign+0x78>                <== NOT EXECUTED
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
a0012858:	ebffd346 	bl	a0007578 <malloc_deferred_frees_process>       <== NOT EXECUTED
  Heap_Control *heap,                                                 
  uintptr_t size,                                                     
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return                                                              
a001285c:	e59f3060 	ldr	r3, [pc, #96]	; a00128c4 <rtems_memalign+0x98><== NOT EXECUTED
a0012860:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0012864:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0012868:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a001286c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0012870:	ebffe7c0 	bl	a000c778 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
  return_this = _Protected_heap_Allocate_aligned(                     
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
a0012874:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a0012878:	0a00000e 	beq	a00128b8 <rtems_memalign+0x8c>                <== NOT EXECUTED
    return ENOMEM;                                                    
                                                                      
  /*                                                                  
   *  If configured, update the more involved statistics              
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
a001287c:	e59f3044 	ldr	r3, [pc, #68]	; a00128c8 <rtems_memalign+0x9c><== NOT EXECUTED
a0012880:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0012884:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0012888:	0a000002 	beq	a0012898 <rtems_memalign+0x6c>                <== NOT EXECUTED
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
a001288c:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0012890:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0012894:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  *pointer = return_this;                                             
a0012898:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
  return 0;                                                           
a001289c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00128a0:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
       !malloc_is_system_state_OK() )                                 
a00128a4:	ebffd31f 	bl	a0007528 <malloc_is_system_state_OK>           <== NOT EXECUTED
  *pointer = NULL;                                                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
a00128a8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00128ac:	1affffe9 	bne	a0012858 <rtems_memalign+0x2c>                <== NOT EXECUTED
       !malloc_is_system_state_OK() )                                 
    return EINVAL;                                                    
a00128b0:	e3a00016 	mov	r0, #22                                       <== NOT EXECUTED
a00128b4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
    return ENOMEM;                                                    
a00128b8:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
  if ( rtems_malloc_statistics_helpers )                              
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
                                                                      
  *pointer = return_this;                                             
  return 0;                                                           
}                                                                     
a00128bc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0017838 <rtems_message_queue_broadcast>: rtems_id id, const void *buffer, size_t size, uint32_t *count ) {
a0017838:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
  CORE_message_queue_Status       core_status;                        
                                                                      
  if ( !buffer )                                                      
a001783c:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  rtems_id    id,                                                     
  const void *buffer,                                                 
  size_t      size,                                                   
  uint32_t   *count                                                   
)                                                                     
{                                                                     
a0017840:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a0017844:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0017848:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a001784c:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
  CORE_message_queue_Status       core_status;                        
                                                                      
  if ( !buffer )                                                      
a0017850:	0a000016 	beq	a00178b0 <rtems_message_queue_broadcast+0x78> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !count )                                                       
a0017854:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0017858:	0a000014 	beq	a00178b0 <rtems_message_queue_broadcast+0x78> <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Message_queue_Control *)                                    
     _Objects_Get( &_Message_queue_Information, id, location );       
a001785c:	e59f0054 	ldr	r0, [pc, #84]	; a00178b8 <rtems_message_queue_broadcast+0x80><== NOT EXECUTED
a0017860:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017864:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a0017868:	eb0014f1 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a001786c:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0017870:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
a0017874:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017878:	1a00000a 	bne	a00178a8 <rtems_message_queue_broadcast+0x70> <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      core_status = _CORE_message_queue_Broadcast(                    
a001787c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0017880:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0017884:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0017888:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a001788c:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0017890:	e58d7004 	str	r7, [sp, #4]                                  <== NOT EXECUTED
a0017894:	eb000dcb 	bl	a001afc8 <_CORE_message_queue_Broadcast>       <== NOT EXECUTED
a0017898:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                        NULL,                                         
                      #endif                                          
                      count                                           
                    );                                                
                                                                      
      _Thread_Enable_dispatch();                                      
a001789c:	eb001837 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return                                                          
a00178a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00178a4:	eb0000d5 	bl	a0017c00 <_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00178a8:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a00178ac:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
a00178b0:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a00178b4:	eafffffb 	b	a00178a8 <rtems_message_queue_broadcast+0x70>   <== NOT EXECUTED
                                                                      

a0011fa8 <rtems_message_queue_create>: uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) {
a0011fa8:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  CORE_message_queue_Attributes   the_msgq_attributes;                
#if defined(RTEMS_MULTIPROCESSING)                                    
  bool                            is_global;                          
#endif                                                                
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0011fac:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
  uint32_t         count,                                             
  size_t           max_message_size,                                  
  rtems_attribute  attribute_set,                                     
  rtems_id        *id                                                 
)                                                                     
{                                                                     
a0011fb0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0011fb4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
a0011fb8:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
a0011fbc:	e59d5020 	ldr	r5, [sp, #32]                                 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
  bool                            is_global;                          
#endif                                                                
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a0011fc0:	03a00003 	moveq	r0, #3                                      <== NOT EXECUTED
  CORE_message_queue_Attributes   the_msgq_attributes;                
#if defined(RTEMS_MULTIPROCESSING)                                    
  bool                            is_global;                          
#endif                                                                
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0011fc4:	0a000008 	beq	a0011fec <rtems_message_queue_create+0x44>    <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a0011fc8:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a0011fcc:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
#endif                                                                
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a0011fd0:	0a000005 	beq	a0011fec <rtems_message_queue_create+0x44>    <== NOT EXECUTED
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&       
       !_System_state_Is_multiprocessing )                            
    return RTEMS_MP_NOT_CONFIGURED;                                   
#endif                                                                
                                                                      
  if ( count == 0 )                                                   
a0011fd4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a0011fd8:	03a0000a 	moveq	r0, #10                                     <== NOT EXECUTED
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&       
       !_System_state_Is_multiprocessing )                            
    return RTEMS_MP_NOT_CONFIGURED;                                   
#endif                                                                
                                                                      
  if ( count == 0 )                                                   
a0011fdc:	0a000002 	beq	a0011fec <rtems_message_queue_create+0x44>    <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  if ( max_message_size == 0 )                                        
a0011fe0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      return RTEMS_INVALID_SIZE;                                      
a0011fe4:	03a00008 	moveq	r0, #8                                      <== NOT EXECUTED
#endif                                                                
                                                                      
  if ( count == 0 )                                                   
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  if ( max_message_size == 0 )                                        
a0011fe8:	1a000001 	bne	a0011ff4 <rtems_message_queue_create+0x4c>    <== NOT EXECUTED
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0011fec:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0011ff0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a0011ff4:	e59f2098 	ldr	r2, [pc, #152]	; a0012094 <rtems_message_queue_create+0xec><== NOT EXECUTED
a0011ff8:	e5921000 	ldr	r1, [r2]                                      <== NOT EXECUTED
a0011ffc:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
a0012000:	e5821000 	str	r1, [r2]                                      <== NOT EXECUTED
#endif                                                                
#endif                                                                
                                                                      
  _Thread_Disable_dispatch();              /* protects object pointer */
                                                                      
  the_message_queue = _Message_queue_Allocate();                      
a0012004:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0012008:	eb001724 	bl	a0017ca0 <_Message_queue_Allocate>             <== NOT EXECUTED
                                                                      
  if ( !the_message_queue ) {                                         
a001200c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
a0012010:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0012014:	0a00001b 	beq	a0012088 <rtems_message_queue_create+0xe0>    <== NOT EXECUTED
  }                                                                   
#endif                                                                
                                                                      
  the_message_queue->attribute_set = attribute_set;                   
                                                                      
  if (_Attributes_Is_priority( attribute_set ) )                      
a0012018:	e2132004 	ands	r2, r3, #4                                   <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_message_queue->attribute_set = attribute_set;                   
a001201c:	e5883010 	str	r3, [r8, #16]                                 <== NOT EXECUTED
                                                                      
  if (_Attributes_Is_priority( attribute_set ) )                      
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
a0012020:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
a0012024:	158d3004 	strne	r3, [sp, #4]                                <== NOT EXECUTED
  else                                                                
    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
a0012028:	058d2004 	streq	r2, [sp, #4]                                <== NOT EXECUTED
                                                                      
  if ( ! _CORE_message_queue_Initialize(                              
a001202c:	e2880014 	add	r0, r8, #20                                   <== NOT EXECUTED
a0012030:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a0012034:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0012038:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a001203c:	eb000478 	bl	a0013224 <_CORE_message_queue_Initialize>      <== NOT EXECUTED
a0012040:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0012044:	1a000005 	bne	a0012060 <rtems_message_queue_create+0xb8>    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Message_queue_Free (                       
  Message_queue_Control *the_message_queue                            
)                                                                     
{                                                                     
  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
a0012048:	e59f0048 	ldr	r0, [pc, #72]	; a0012098 <rtems_message_queue_create+0xf0><== NOT EXECUTED
a001204c:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0012050:	eb000836 	bl	a0014130 <_Objects_Free>                       <== NOT EXECUTED
        _Objects_MP_Close(                                            
          &_Message_queue_Information, the_message_queue->Object.id); 
#endif                                                                
                                                                      
    _Message_queue_Free( the_message_queue );                         
    _Thread_Enable_dispatch();                                        
a0012054:	eb000c09 	bl	a0015080 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
a0012058:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
a001205c:	eaffffe2 	b	a0011fec <rtems_message_queue_create+0x44>      <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0012060:	e59f2030 	ldr	r2, [pc, #48]	; a0012098 <rtems_message_queue_create+0xf0><== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a0012064:	e5983008 	ldr	r3, [r8, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0012068:	e592201c 	ldr	r2, [r2, #28]                                 <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a001206c:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0012070:	e7828721 	str	r8, [r2, r1, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a0012074:	e588700c 	str	r7, [r8, #12]                                 <== NOT EXECUTED
    &_Message_queue_Information,                                      
    &the_message_queue->Object,                                       
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_message_queue->Object.id;                                 
a0012078:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
      name,                                                           
      0                                                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
a001207c:	eb000bff 	bl	a0015080 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a0012080:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0012084:	eaffffd8 	b	a0011fec <rtems_message_queue_create+0x44>      <== NOT EXECUTED
  _Thread_Disable_dispatch();              /* protects object pointer */
                                                                      
  the_message_queue = _Message_queue_Allocate();                      
                                                                      
  if ( !the_message_queue ) {                                         
    _Thread_Enable_dispatch();                                        
a0012088:	eb000bfc 	bl	a0015080 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a001208c:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a0012090:	eaffffd5 	b	a0011fec <rtems_message_queue_create+0x44>      <== NOT EXECUTED
                                                                      

a000fd80 <rtems_message_queue_delete>: */ rtems_status_code rtems_message_queue_delete( rtems_id id ) {
a000fd80:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000fd84:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000fd88:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Message_queue_Control *)                                    
     _Objects_Get( &_Message_queue_Information, id, location );       
a000fd8c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000fd90:	e59f004c 	ldr	r0, [pc, #76]	; a000fde4 <rtems_message_queue_delete+0x64><== NOT EXECUTED
a000fd94:	ebfff08b 	bl	a000bfc8 <_Objects_Get>                        <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a000fd98:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a000fd9c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000fda0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000fda4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a000fda8:	1a00000b 	bne	a000fddc <rtems_message_queue_delete+0x5c>    <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Close( &_Message_queue_Information,                    
a000fdac:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000fdb0:	e59f002c 	ldr	r0, [pc, #44]	; a000fde4 <rtems_message_queue_delete+0x64><== NOT EXECUTED
a000fdb4:	ebffef75 	bl	a000bb90 <_Objects_Close>                      <== NOT EXECUTED
                      &the_message_queue->Object );                   
                                                                      
      _CORE_message_queue_Close(                                      
a000fdb8:	e3a02005 	mov	r2, #5                                        <== NOT EXECUTED
a000fdbc:	e2850014 	add	r0, r5, #20                                   <== NOT EXECUTED
a000fdc0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000fdc4:	eb000198 	bl	a001042c <_CORE_message_queue_Close>           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Message_queue_Free (                       
  Message_queue_Control *the_message_queue                            
)                                                                     
{                                                                     
  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
a000fdc8:	e59f0014 	ldr	r0, [pc, #20]	; a000fde4 <rtems_message_queue_delete+0x64><== NOT EXECUTED
a000fdcc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000fdd0:	ebfff023 	bl	a000be64 <_Objects_Free>                       <== NOT EXECUTED
          0,                                 /* Not used */           
          0                                                           
        );                                                            
      }                                                               
#endif                                                                
      _Thread_Enable_dispatch();                                      
a000fdd4:	ebfff3ac 	bl	a000cc8c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000fdd8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000fddc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000fde0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0017a18 <rtems_message_queue_flush>: rtems_status_code rtems_message_queue_flush( rtems_id id, uint32_t *count ) {
a0017a18:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
a0017a1c:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_message_queue_flush(                          
  rtems_id  id,                                                       
  uint32_t *count                                                     
)                                                                     
{                                                                     
a0017a20:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017a24:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
a0017a28:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
a0017a2c:	0a00000b 	beq	a0017a60 <rtems_message_queue_flush+0x48>     <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Message_queue_Control *)                                    
     _Objects_Get( &_Message_queue_Information, id, location );       
a0017a30:	e59f0030 	ldr	r0, [pc, #48]	; a0017a68 <rtems_message_queue_flush+0x50><== NOT EXECUTED
a0017a34:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017a38:	eb00147d 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017a3c:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a0017a40:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017a44:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017a48:	1a000004 	bne	a0017a60 <rtems_message_queue_flush+0x48>     <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
a0017a4c:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0017a50:	eb000d85 	bl	a001b06c <_CORE_message_queue_Flush>           <== NOT EXECUTED
a0017a54:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0017a58:	eb0017c8 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0017a5c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017a60:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017a64:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0017a6c <rtems_message_queue_get_number_pending>: rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) {
a0017a6c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
a0017a70:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_message_queue_get_number_pending(             
  rtems_id  id,                                                       
  uint32_t *count                                                     
)                                                                     
{                                                                     
a0017a74:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017a78:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
a0017a7c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
                                                                      
  if ( !count )                                                       
a0017a80:	0a00000a 	beq	a0017ab0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
a0017a84:	e59f002c 	ldr	r0, [pc, #44]	; a0017ab8 <rtems_message_queue_get_number_pending+0x4c><== NOT EXECUTED
a0017a88:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017a8c:	eb001468 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017a90:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a0017a94:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017a98:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !count )                                                       
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017a9c:	1a000003 	bne	a0017ab0 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      *count = the_message_queue->message_queue.number_of_pending_messages;
a0017aa0:	e590305c 	ldr	r3, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a0017aa4:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0017aa8:	eb0017b4 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0017aac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017ab0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017ab4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a001209c <rtems_message_queue_ident>: rtems_status_code rtems_message_queue_ident( rtems_name name, uint32_t node, rtems_id *id ) {
a001209c:	e1a0c001 	mov	ip, r1                                        <== NOT EXECUTED
a00120a0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00120a4:	e1a0e000 	mov	lr, r0                                        <== NOT EXECUTED
a00120a8:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a00120ac:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
a00120b0:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a00120b4:	e59f000c 	ldr	r0, [pc, #12]	; a00120c8 <rtems_message_queue_ident+0x2c><== NOT EXECUTED
a00120b8:	eb0008ca 	bl	a00143e8 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    node,                                                             
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a00120bc:	e59f3008 	ldr	r3, [pc, #8]	; a00120cc <rtems_message_queue_ident+0x30><== NOT EXECUTED
}                                                                     
a00120c0:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a00120c4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00120d0 <rtems_message_queue_receive>: void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) {
a00120d0:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
  bool                            wait;                               
                                                                      
  if ( !buffer )                                                      
a00120d4:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
  void           *buffer,                                             
  size_t         *size,                                               
  rtems_option    option_set,                                         
  rtems_interval  timeout                                             
)                                                                     
{                                                                     
a00120d8:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a00120dc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a00120e0:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a00120e4:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
  register Message_queue_Control *the_message_queue;                  
  Objects_Locations               location;                           
  bool                            wait;                               
                                                                      
  if ( !buffer )                                                      
a00120e8:	0a000019 	beq	a0012154 <rtems_message_queue_receive+0x84>   <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !size )                                                        
a00120ec:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a00120f0:	0a000017 	beq	a0012154 <rtems_message_queue_receive+0x84>   <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Message_queue_Control *)                                    
     _Objects_Get( &_Message_queue_Information, id, location );       
a00120f4:	e59f0060 	ldr	r0, [pc, #96]	; a001215c <rtems_message_queue_receive+0x8c><== NOT EXECUTED
a00120f8:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a00120fc:	eb000864 	bl	a0014294 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0012100:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0012104:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0012108:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !size )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a001210c:	1a00000e 	bne	a001214c <rtems_message_queue_receive+0x7c>   <== NOT EXECUTED
      if ( _Options_Is_no_wait( option_set ) )                        
        wait = false;                                                 
      else                                                            
        wait = true;                                                  
                                                                      
      _CORE_message_queue_Seize(                                      
a0012110:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (                       
  rtems_option option_set                                             
)                                                                     
{                                                                     
   return (option_set & RTEMS_NO_WAIT) ? true : false;                
a0012114:	e2066001 	and	r6, r6, #1                                    <== NOT EXECUTED
a0012118:	e5901008 	ldr	r1, [r0, #8]                                  <== NOT EXECUTED
a001211c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0012120:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0012124:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
a0012128:	e2266001 	eor	r6, r6, #1                                    <== NOT EXECUTED
a001212c:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0012130:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0012134:	eb00046b 	bl	a00132e8 <_CORE_message_queue_Seize>           <== NOT EXECUTED
        buffer,                                                       
        size,                                                         
        wait,                                                         
        timeout                                                       
      );                                                              
      _Thread_Enable_dispatch();                                      
a0012138:	eb000bd0 	bl	a0015080 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return _Message_queue_Translate_core_message_queue_return_code( 
        _Thread_Executing->Wait.return_code                           
a001213c:	e59f301c 	ldr	r3, [pc, #28]	; a0012160 <rtems_message_queue_receive+0x90><== NOT EXECUTED
a0012140:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
        size,                                                         
        wait,                                                         
        timeout                                                       
      );                                                              
      _Thread_Enable_dispatch();                                      
      return _Message_queue_Translate_core_message_queue_return_code( 
a0012144:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0012148:	eb000024 	bl	a00121e0 <_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a001214c:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a0012150:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !size )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a0012154:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a0012158:	eafffffb 	b	a001214c <rtems_message_queue_receive+0x7c>     <== NOT EXECUTED
                                                                      

a0012164 <rtems_message_queue_send>: rtems_status_code rtems_message_queue_send( rtems_id id, const void *buffer, size_t size ) {
a0012164:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
a0012168:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_message_queue_send(                           
  rtems_id    id,                                                     
  const void *buffer,                                                 
  size_t      size                                                    
)                                                                     
{                                                                     
a001216c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0012170:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
a0012174:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a0012178:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
a001217c:	0a000014 	beq	a00121d4 <rtems_message_queue_send+0x70>      <== NOT EXECUTED
a0012180:	e59f0054 	ldr	r0, [pc, #84]	; a00121dc <rtems_message_queue_send+0x78><== NOT EXECUTED
a0012184:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0012188:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
a001218c:	eb000840 	bl	a0014294 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0012190:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0012194:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
a0012198:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a001219c:	1a00000c 	bne	a00121d4 <rtems_message_queue_send+0x70>      <== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,                       
  Watchdog_Interval                          timeout                  
)                                                                     
{                                                                     
  return _CORE_message_queue_Submit(                                  
a00121a0:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a00121a4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a00121a8:	e98d000c 	stmib	sp, {r2, r3}                                <== NOT EXECUTED
a00121ac:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a00121b0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a00121b4:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a00121b8:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a00121bc:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a00121c0:	eb000480 	bl	a00133c8 <_CORE_message_queue_Submit>          <== NOT EXECUTED
a00121c4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
        MESSAGE_QUEUE_MP_HANDLER,                                     
        false,   /* sender does not block */                          
        0        /* no timeout */                                     
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
a00121c8:	eb000bac 	bl	a0015080 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      /*                                                              
       *  Since this API does not allow for blocking sends, we can directly
       *  return the returned status.                                 
       */                                                             
                                                                      
      return _Message_queue_Translate_core_message_queue_return_code(status);
a00121cc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00121d0:	eb000002 	bl	a00121e0 <_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00121d4:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a00121d8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0017c10 <rtems_message_queue_urgent>: rtems_status_code rtems_message_queue_urgent( rtems_id id, const void *buffer, size_t size ) {
a0017c10:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
a0017c14:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_message_queue_urgent(                         
  rtems_id    id,                                                     
  const void *buffer,                                                 
  size_t      size                                                    
)                                                                     
{                                                                     
a0017c18:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0017c1c:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
a0017c20:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a0017c24:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  register Message_queue_Control  *the_message_queue;                 
  Objects_Locations                location;                          
  CORE_message_queue_Status        status;                            
                                                                      
  if ( !buffer )                                                      
a0017c28:	0a000014 	beq	a0017c80 <rtems_message_queue_urgent+0x70>    <== NOT EXECUTED
a0017c2c:	e59f0054 	ldr	r0, [pc, #84]	; a0017c88 <rtems_message_queue_urgent+0x78><== NOT EXECUTED
a0017c30:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017c34:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
a0017c38:	eb0013fd 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017c3c:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a0017c40:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017c44:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_message_queue = _Message_queue_Get( id, &location );            
  switch ( location ) {                                               
a0017c48:	1a00000c 	bne	a0017c80 <rtems_message_queue_urgent+0x70>    <== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,                       
  Watchdog_Interval                          timeout                  
)                                                                     
{                                                                     
  return _CORE_message_queue_Submit(                                  
a0017c4c:	e3a02102 	mov	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0017c50:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0017c54:	e98d000c 	stmib	sp, {r2, r3}                                <== NOT EXECUTED
a0017c58:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a0017c5c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0017c60:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0017c64:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0017c68:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0017c6c:	eb000d85 	bl	a001b288 <_CORE_message_queue_Submit>          <== NOT EXECUTED
a0017c70:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
        id,                                                           
        MESSAGE_QUEUE_MP_HANDLER,                                     
        false,   /* sender does not block */                          
        0        /* no timeout */                                     
      );                                                              
      _Thread_Enable_dispatch();                                      
a0017c74:	eb001741 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      /*                                                              
       *  Since this API does not allow for blocking sends, we can directly
       *  return the returned status.                                 
       */                                                             
                                                                      
      return _Message_queue_Translate_core_message_queue_return_code(status);
a0017c78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0017c7c:	ebffffdf 	bl	a0017c00 <_Message_queue_Translate_core_message_queue_return_code><== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017c80:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a0017c84:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0010f00 <rtems_mkdir>: return (retval); } int rtems_mkdir(const char *path, mode_t mode) {
a0010f00:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0010f04:	e24dd048 	sub	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0010f08:	e1a0a001 	mov	sl, r1                                        <== NOT EXECUTED
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
a0010f0c:	eb000a37 	bl	a00137f0 <strdup>                              <== NOT EXECUTED
                                                                      
  if (dup_path != NULL) {                                             
a0010f10:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0010f14:	0a000055 	beq	a0011070 <rtems_mkdir+0x170>                  <== NOT EXECUTED
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
a0010f18:	e5d63000 	ldrb	r3, [r6]                                     <== NOT EXECUTED
a0010f1c:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
a0010f20:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0010f24:	e353002f 	cmp	r3, #47	; 0x2f                                <== NOT EXECUTED
    ++p;                                                              
a0010f28:	05d63001 	ldrbeq	r3, [r6, #1]                               <== NOT EXECUTED
a0010f2c:	02865001 	addeq	r5, r6, #1                                  <== NOT EXECUTED
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
a0010f30:	11a05006 	movne	r5, r6                                      <== NOT EXECUTED
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
a0010f34:	e3a0802f 	mov	r8, #47	; 0x2f                                <== NOT EXECUTED
a0010f38:	e1a09007 	mov	r9, r7                                        <== NOT EXECUTED
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
      if (errno == EEXIST || errno == EISDIR) {                       
        if (stat(path, &sb) < 0) {                                    
a0010f3c:	e1a0b00d 	mov	fp, sp                                        <== NOT EXECUTED
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
a0010f40:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
a0010f44:	05c53000 	strbeq	r3, [r5]                                   <== NOT EXECUTED
a0010f48:	03a04001 	moveq	r4, #1                                      <== NOT EXECUTED
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
a0010f4c:	0a000006 	beq	a0010f6c <rtems_mkdir+0x6c>                   <== NOT EXECUTED
      last = 1;                                                       
    else if (p[0] != '/')                                             
a0010f50:	e353002f 	cmp	r3, #47	; 0x2f                                <== NOT EXECUTED
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
a0010f54:	15f53001 	ldrbne	r3, [r5, #1]!                              <== NOT EXECUTED
a0010f58:	1afffff8 	bne	a0010f40 <rtems_mkdir+0x40>                   <== NOT EXECUTED
    if (p[0] == '\0')                                                 
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
    if (!last && p[1] == '\0')                                        
a0010f5c:	e5d54001 	ldrb	r4, [r5, #1]                                 <== NOT EXECUTED
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
a0010f60:	e5c59000 	strb	r9, [r5]                                     <== NOT EXECUTED
    if (!last && p[1] == '\0')                                        
a0010f64:	e2744001 	rsbs	r4, r4, #1                                   <== NOT EXECUTED
a0010f68:	33a04000 	movcc	r4, #0                                      <== NOT EXECUTED
      last = 1;                                                       
    if (first) {                                                      
a0010f6c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0010f70:	1a000031 	bne	a001103c <rtems_mkdir+0x13c>                  <== NOT EXECUTED
      oumask = umask(0);                                              
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
a0010f74:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
a0010f78:	03a01f7f 	moveq	r1, #508	; 0x1fc                            <== NOT EXECUTED
a0010f7c:	02811003 	addeq	r1, r1, #3                                  <== NOT EXECUTED
      oumask = umask(0);                                              
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
a0010f80:	1a000011 	bne	a0010fcc <rtems_mkdir+0xcc>                   <== NOT EXECUTED
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
a0010f84:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010f88:	ebffdb7b 	bl	a0007d7c <mkdir>                               <== NOT EXECUTED
a0010f8c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010f90:	ba000014 	blt	a0010fe8 <rtems_mkdir+0xe8>                   <== NOT EXECUTED
      } else {                                                        
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
a0010f94:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0010f98:	0a000007 	beq	a0010fbc <rtems_mkdir+0xbc>                   <== NOT EXECUTED
a0010f9c:	e3a04001 	mov	r4, #1                                        <== NOT EXECUTED
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
a0010fa0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010fa4:	ebffd97e 	bl	a00075a4 <free>                                <== NOT EXECUTED
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
a0010fa8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0010fac:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
a0010fb0:	0a00002e 	beq	a0011070 <rtems_mkdir+0x170>                  <== NOT EXECUTED
}                                                                     
a0010fb4:	e28dd048 	add	sp, sp, #72	; 0x48                            <== NOT EXECUTED
a0010fb8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
a0010fbc:	e5c58000 	strb	r8, [r5]                                     <== NOT EXECUTED
a0010fc0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0010fc4:	e5f53001 	ldrb	r3, [r5, #1]!                                <== NOT EXECUTED
a0010fc8:	eaffffdc 	b	a0010f40 <rtems_mkdir+0x40>                     <== NOT EXECUTED
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
a0010fcc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010fd0:	eb00005b 	bl	a0011144 <umask>                               <== NOT EXECUTED
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
a0010fd4:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a0010fd8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010fdc:	ebffdb66 	bl	a0007d7c <mkdir>                               <== NOT EXECUTED
a0010fe0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010fe4:	aaffffea 	bge	a0010f94 <rtems_mkdir+0x94>                   <== NOT EXECUTED
      if (errno == EEXIST || errno == EISDIR) {                       
a0010fe8:	eb00061e 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a0010fec:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010ff0:	e3530011 	cmp	r3, #17                                       <== NOT EXECUTED
a0010ff4:	0a000003 	beq	a0011008 <rtems_mkdir+0x108>                  <== NOT EXECUTED
a0010ff8:	eb00061a 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a0010ffc:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0011000:	e3530015 	cmp	r3, #21                                       <== NOT EXECUTED
a0011004:	1a000024 	bne	a001109c <rtems_mkdir+0x19c>                  <== NOT EXECUTED
        if (stat(path, &sb) < 0) {                                    
a0011008:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a001100c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0011010:	eb000024 	bl	a00110a8 <stat>                                <== NOT EXECUTED
a0011014:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0011018:	ba00001f 	blt	a001109c <rtems_mkdir+0x19c>                  <== NOT EXECUTED
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
a001101c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0011020:	e2033a0f 	and	r3, r3, #61440	; 0xf000                       <== NOT EXECUTED
a0011024:	e3530901 	cmp	r3, #16384	; 0x4000                           <== NOT EXECUTED
a0011028:	1a000012 	bne	a0011078 <rtems_mkdir+0x178>                  <== NOT EXECUTED
          else                                                        
            errno = ENOTDIR;                                          
          retval = 0;                                                 
          break;                                                      
        }                                                             
        if (last)                                                     
a001102c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0011030:	0affffe1 	beq	a0010fbc <rtems_mkdir+0xbc>                   <== NOT EXECUTED
          retval = 2;                                                 
a0011034:	e3a04002 	mov	r4, #2                                        <== NOT EXECUTED
a0011038:	eaffffd8 	b	a0010fa0 <rtems_mkdir+0xa0>                     <== NOT EXECUTED
       *    mkdir [-m mode] dir                                       
       *                                                              
       * We change the user's umask and then restore it,              
       * instead of doing chmod's.                                    
       */                                                             
      oumask = umask(0);                                              
a001103c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0011040:	eb00003f 	bl	a0011144 <umask>                               <== NOT EXECUTED
a0011044:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
a0011048:	e3c000c0 	bic	r0, r0, #192	; 0xc0                           <== NOT EXECUTED
a001104c:	eb00003c 	bl	a0011144 <umask>                               <== NOT EXECUTED
a0011050:	eaffffc7 	b	a0010f74 <rtems_mkdir+0x74>                     <== NOT EXECUTED
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
          if (last)                                                   
            errno = EEXIST;                                           
          else                                                        
            errno = ENOTDIR;                                          
a0011054:	eb000603 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a0011058:	e3a03014 	mov	r3, #20                                       <== NOT EXECUTED
a001105c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
    (void)umask(oumask);                                              
a0011060:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0011064:	eb000036 	bl	a0011144 <umask>                               <== NOT EXECUTED
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
a0011068:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a001106c:	ebffd94c 	bl	a00075a4 <free>                                <== NOT EXECUTED
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
a0011070:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0011074:	eaffffce 	b	a0010fb4 <rtems_mkdir+0xb4>                     <== NOT EXECUTED
      if (errno == EEXIST || errno == EISDIR) {                       
        if (stat(path, &sb) < 0) {                                    
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
          if (last)                                                   
a0011078:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a001107c:	0afffff4 	beq	a0011054 <rtems_mkdir+0x154>                  <== NOT EXECUTED
            errno = EEXIST;                                           
a0011080:	eb0005f8 	bl	a0012868 <__errno>                             <== NOT EXECUTED
a0011084:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
a0011088:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
a001108c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0011090:	ebffd943 	bl	a00075a4 <free>                                <== NOT EXECUTED
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
a0011094:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0011098:	eaffffc5 	b	a0010fb4 <rtems_mkdir+0xb4>                     <== NOT EXECUTED
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
a001109c:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a00110a0:	0affffee 	beq	a0011060 <rtems_mkdir+0x160>                  <== NOT EXECUTED
a00110a4:	eaffffef 	b	a0011068 <rtems_mkdir+0x168>                    <== NOT EXECUTED
                                                                      

a000b8e8 <rtems_object_api_maximum_class>: int rtems_object_api_maximum_class( int api ) { return _Objects_API_maximum_class(api);
a000b8e8:	ea00063a 	b	a000d1d8 <_Objects_API_maximum_class>           <== NOT EXECUTED
                                                                      

a000b8ec <rtems_object_api_minimum_class>: */ RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid( uint32_t the_api ) { if ( !the_api || the_api > OBJECTS_APIS_LAST )
a000b8ec:	e2400001 	sub	r0, r0, #1                                    <== NOT EXECUTED
  uint32_t api                                                        
)                                                                     
{                                                                     
  if ( _Objects_Is_api_valid( api ) )                                 
    return 1;                                                         
  return -1;                                                          
a000b8f0:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
}                                                                     
a000b8f4:	33a00001 	movcc	r0, #1                                      <== NOT EXECUTED
a000b8f8:	23e00000 	mvncs	r0, #0                                      <== NOT EXECUTED
a000b8fc:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000b900 <rtems_object_get_api_class_name>: ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API )
a000b900:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
                                                                      
const char *rtems_object_get_api_class_name(                          
  int the_api,                                                        
  int the_class                                                       
)                                                                     
{                                                                     
a000b904:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *api_assoc;                                     
  const rtems_assoc_t *class_assoc;                                   
                                                                      
  if ( the_api == OBJECTS_INTERNAL_API )                              
a000b908:	0a000004 	beq	a000b920 <rtems_object_get_api_class_name+0x20><== NOT EXECUTED
    api_assoc = rtems_object_api_internal_assoc;                      
  else if ( the_api == OBJECTS_CLASSIC_API )                          
a000b90c:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
    api_assoc = rtems_object_api_classic_assoc;                       
a000b910:	059f0024 	ldreq	r0, [pc, #36]	; a000b93c <rtems_object_get_api_class_name+0x3c><== NOT EXECUTED
  const rtems_assoc_t *api_assoc;                                     
  const rtems_assoc_t *class_assoc;                                   
                                                                      
  if ( the_api == OBJECTS_INTERNAL_API )                              
    api_assoc = rtems_object_api_internal_assoc;                      
  else if ( the_api == OBJECTS_CLASSIC_API )                          
a000b914:	0a000002 	beq	a000b924 <rtems_object_get_api_class_name+0x24><== NOT EXECUTED
#ifdef RTEMS_POSIX_API                                                
  else if ( the_api == OBJECTS_POSIX_API )                            
    api_assoc = rtems_object_api_posix_assoc;                         
#endif                                                                
  else                                                                
    return "BAD API";                                                 
a000b918:	e59f0020 	ldr	r0, [pc, #32]	; a000b940 <rtems_object_get_api_class_name+0x40><== NOT EXECUTED
a000b91c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
{                                                                     
  const rtems_assoc_t *api_assoc;                                     
  const rtems_assoc_t *class_assoc;                                   
                                                                      
  if ( the_api == OBJECTS_INTERNAL_API )                              
    api_assoc = rtems_object_api_internal_assoc;                      
a000b920:	e59f001c 	ldr	r0, [pc, #28]	; a000b944 <rtems_object_get_api_class_name+0x44><== NOT EXECUTED
  else if ( the_api == OBJECTS_POSIX_API )                            
    api_assoc = rtems_object_api_posix_assoc;                         
#endif                                                                
  else                                                                
    return "BAD API";                                                 
  class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );     
a000b924:	eb0013f6 	bl	a0010904 <rtems_assoc_ptr_by_local>            <== NOT EXECUTED
  if ( class_assoc )                                                  
a000b928:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return class_assoc->name;                                         
a000b92c:	15900000 	ldrne	r0, [r0]                                    <== NOT EXECUTED
    api_assoc = rtems_object_api_posix_assoc;                         
#endif                                                                
  else                                                                
    return "BAD API";                                                 
  class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );     
  if ( class_assoc )                                                  
a000b930:	149df004 	popne	{pc}		; (ldrne pc, [sp], #4)                <== NOT EXECUTED
    return class_assoc->name;                                         
  return "BAD CLASS";                                                 
a000b934:	e59f000c 	ldr	r0, [pc, #12]	; a000b948 <rtems_object_get_api_class_name+0x48><== NOT EXECUTED
}                                                                     
a000b938:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000b94c <rtems_object_get_api_name>: }; const char *rtems_object_get_api_name( int api ) {
a000b94c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000b950:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  const rtems_assoc_t *api_assoc;                                     
                                                                      
  api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
a000b954:	e59f0010 	ldr	r0, [pc, #16]	; a000b96c <rtems_object_get_api_name+0x20><== NOT EXECUTED
a000b958:	eb0013e9 	bl	a0010904 <rtems_assoc_ptr_by_local>            <== NOT EXECUTED
  if ( api_assoc )                                                    
a000b95c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return api_assoc->name;                                           
a000b960:	15900000 	ldrne	r0, [r0]                                    <== NOT EXECUTED
  return "BAD CLASS";                                                 
a000b964:	059f0004 	ldreq	r0, [pc, #4]	; a000b970 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}                                                                     
a000b968:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000b9ac <rtems_object_get_class_information>: rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) {
a000b9ac:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  int                  i;                                             
                                                                      
  /*                                                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
a000b9b0:	e2524000 	subs	r4, r2, #0                                   <== NOT EXECUTED
a000b9b4:	0a00001c 	beq	a000ba2c <rtems_object_get_class_information+0x80><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
a000b9b8:	e1a01801 	lsl	r1, r1, #16                                   <== NOT EXECUTED
a000b9bc:	e1a01821 	lsr	r1, r1, #16                                   <== NOT EXECUTED
a000b9c0:	eb0006e3 	bl	a000d554 <_Objects_Get_information>            <== NOT EXECUTED
  if ( !obj_info )                                                    
a000b9c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b9c8:	0a000019 	beq	a000ba34 <rtems_object_get_class_information+0x88><== NOT EXECUTED
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
a000b9cc:	e1d0c1b0 	ldrh	ip, [r0, #16]                                <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
a000b9d0:	e5901008 	ldr	r1, [r0, #8]                                  <== NOT EXECUTED
  info->maximum_id  = obj_info->maximum_id;                           
a000b9d4:	e590200c 	ldr	r2, [r0, #12]                                 <== NOT EXECUTED
  info->auto_extend = obj_info->auto_extend;                          
a000b9d8:	e5d03012 	ldrb	r3, [r0, #18]                                <== NOT EXECUTED
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
a000b9dc:	e35c0000 	cmp	ip, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  /*                                                                  
   * Return information about this object class to the user.          
   */                                                                 
  info->minimum_id  = obj_info->minimum_id;                           
a000b9e0:	e8840006 	stm	r4, {r1, r2}                                  <== NOT EXECUTED
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
a000b9e4:	e5c4300c 	strb	r3, [r4, #12]                                <== NOT EXECUTED
  info->maximum     = obj_info->maximum;                              
a000b9e8:	e584c008 	str	ip, [r4, #8]                                  <== NOT EXECUTED
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
a000b9ec:	01a0500c 	moveq	r5, ip                                      <== NOT EXECUTED
a000b9f0:	0a00000a 	beq	a000ba20 <rtems_object_get_class_information+0x74><== NOT EXECUTED
a000b9f4:	e590001c 	ldr	r0, [r0, #28]                                 <== NOT EXECUTED
a000b9f8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a000b9fc:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
a000ba00:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    if ( !obj_info->local_table[i] )                                  
a000ba04:	e7901102 	ldr	r1, [r0, r2, lsl #2]                          <== NOT EXECUTED
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
a000ba08:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a000ba0c:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
    if ( !obj_info->local_table[i] )                                  
a000ba10:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
      unallocated++;                                                  
a000ba14:	02855001 	addeq	r5, r5, #1                                  <== NOT EXECUTED
  info->minimum_id  = obj_info->minimum_id;                           
  info->maximum_id  = obj_info->maximum_id;                           
  info->auto_extend = obj_info->auto_extend;                          
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
a000ba18:	e15c0003 	cmp	ip, r3                                        <== NOT EXECUTED
a000ba1c:	2afffff8 	bcs	a000ba04 <rtems_object_get_class_information+0x58><== NOT EXECUTED
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
a000ba20:	e5845010 	str	r5, [r4, #16]                                 <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a000ba24:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000ba28:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a000ba2c:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000ba30:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
  if ( !obj_info )                                                    
    return RTEMS_INVALID_NUMBER;                                      
a000ba34:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000ba38:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000ad34 <rtems_object_get_classic_name>: rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) {
a000ad34:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
  Objects_Name                      name_u;                           
                                                                      
  if ( !name )                                                        
a000ad38:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_object_get_classic_name(                      
  rtems_id      id,                                                   
  rtems_name   *name                                                  
)                                                                     
{                                                                     
a000ad3c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
  Objects_Name                      name_u;                           
                                                                      
  if ( !name )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a000ad40:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Objects_Name_or_id_lookup_errors  status;                           
  Objects_Name                      name_u;                           
                                                                      
  if ( !name )                                                        
a000ad44:	0a000005 	beq	a000ad60 <rtems_object_get_classic_name+0x2c> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  status = _Objects_Id_to_name( id, &name_u );                        
a000ad48:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ad4c:	eb000710 	bl	a000c994 <_Objects_Id_to_name>                 <== NOT EXECUTED
                                                                      
  *name = name_u.name_u32;                                            
a000ad50:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000ad54:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
  return _Status_Object_name_errors_to_status[ status ];              
a000ad58:	e59f3008 	ldr	r3, [pc, #8]	; a000ad68 <rtems_object_get_classic_name+0x34><== NOT EXECUTED
a000ad5c:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
}                                                                     
a000ad60:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000ad64:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000af5c <rtems_object_get_name>: Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name );
a000af5c:	ea0007a1 	b	a000cde8 <_Objects_Get_name_as_string>          <== NOT EXECUTED
                                                                      

a000ba40 <rtems_object_id_api_maximum>: #undef rtems_object_id_api_maximum int rtems_object_id_api_maximum(void) { return OBJECTS_APIS_LAST; }
a000ba40:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
a000ba44:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba48 <rtems_object_id_api_minimum>: #undef rtems_object_id_api_minimum int rtems_object_id_api_minimum(void) { return OBJECTS_INTERNAL_API; }
a000ba48:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000ba4c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba50 <rtems_object_id_get_api>: */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
a000ba50:	e1a00c20 	lsr	r0, r0, #24                                   <== NOT EXECUTED
int rtems_object_id_get_api(                                          
  rtems_id id                                                         
)                                                                     
{                                                                     
  return _Objects_Get_API( id );                                      
}                                                                     
a000ba54:	e2000007 	and	r0, r0, #7                                    <== NOT EXECUTED
a000ba58:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba5c <rtems_object_id_get_class>: int rtems_object_id_get_class( rtems_id id ) { return _Objects_Get_class( id ); }
a000ba5c:	e1a00da0 	lsr	r0, r0, #27                                   <== NOT EXECUTED
a000ba60:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba64 <rtems_object_id_get_index>: #undef rtems_object_id_get_index int rtems_object_id_get_index( rtems_id id ) { return _Objects_Get_index( id );
a000ba64:	e1a00800 	lsl	r0, r0, #16                                   <== NOT EXECUTED
}                                                                     
a000ba68:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
a000ba6c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba70 <rtems_object_id_get_node>: * be a single processor system. */ #if defined(RTEMS_USE_16_BIT_OBJECT) return 1; #else return (id >> OBJECTS_NODE_START_BIT) & OBJECTS_NODE_VALID_BITS;
a000ba70:	e1a00820 	lsr	r0, r0, #16                                   <== NOT EXECUTED
int rtems_object_id_get_node(                                         
  rtems_id id                                                         
)                                                                     
{                                                                     
  return _Objects_Get_node( id );                                     
}                                                                     
a000ba74:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
a000ba78:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000ba7c <rtems_object_set_name>: */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) {
a000ba7c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Objects_Information *information;                                   
  Objects_Locations    location;                                      
  Objects_Control     *the_object;                                    
  Objects_Id           tmpId;                                         
                                                                      
  if ( !name )                                                        
a000ba80:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
 */                                                                   
rtems_status_code rtems_object_set_name(                              
  rtems_id       id,                                                  
  const char    *name                                                 
)                                                                     
{                                                                     
a000ba84:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Objects_Locations    location;                                      
  Objects_Control     *the_object;                                    
  Objects_Id           tmpId;                                         
                                                                      
  if ( !name )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a000ba88:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  Objects_Information *information;                                   
  Objects_Locations    location;                                      
  Objects_Control     *the_object;                                    
  Objects_Id           tmpId;                                         
                                                                      
  if ( !name )                                                        
a000ba8c:	0a000010 	beq	a000bad4 <rtems_object_set_name+0x58>         <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
a000ba90:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ba94:	059f3058 	ldreq	r3, [pc, #88]	; a000baf4 <rtems_object_set_name+0x78><== NOT EXECUTED
a000ba98:	11a04000 	movne	r4, r0                                      <== NOT EXECUTED
a000ba9c:	05933004 	ldreq	r3, [r3, #4]                                <== NOT EXECUTED
a000baa0:	05934008 	ldreq	r4, [r3, #8]                                <== NOT EXECUTED
                                                                      
  information  = _Objects_Get_information_id( tmpId );                
a000baa4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000baa8:	eb0006a4 	bl	a000d540 <_Objects_Get_information_id>         <== NOT EXECUTED
  if ( !information )                                                 
a000baac:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a000bab0:	0a000006 	beq	a000bad0 <rtems_object_set_name+0x54>         <== NOT EXECUTED
    return RTEMS_INVALID_ID;                                          
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
a000bab4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000bab8:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000babc:	eb00071b 	bl	a000d730 <_Objects_Get>                        <== NOT EXECUTED
  switch ( location ) {                                               
a000bac0:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
                                                                      
  information  = _Objects_Get_information_id( tmpId );                
  if ( !information )                                                 
    return RTEMS_INVALID_ID;                                          
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
a000bac4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  switch ( location ) {                                               
a000bac8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000bacc:	0a000002 	beq	a000badc <rtems_object_set_name+0x60>         <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000bad0:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
}                                                                     
a000bad4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000bad8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Set_name( information, the_object, name );             
a000badc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000bae0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000bae4:	eb000789 	bl	a000d910 <_Objects_Set_name>                   <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a000bae8:	eb000a83 	bl	a000e4fc <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000baec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000baf0:	eafffff7 	b	a000bad4 <rtems_object_set_name+0x58>           <== NOT EXECUTED
                                                                      

a000aff0 <rtems_panic>: void rtems_panic( const char *printf_format, ... ) {
a000aff0:	e92d000f 	push	{r0, r1, r2, r3}                             <== NOT EXECUTED
a000aff4:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a000aff8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
a000affc:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
a000b000:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a000b004:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
a000b008:	e3a00202 	mov	r0, #536870912	; 0x20000000                   <== NOT EXECUTED
  ...                                                                 
)                                                                     
{                                                                     
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
a000b00c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
a000b010:	ebffff7f 	bl	a000ae14 <rtems_verror>                        <== NOT EXECUTED
  va_end(arglist);                                                    
                                                                      
  rtems_error(0, "fatal error, exiting");                             
a000b014:	e59f1010 	ldr	r1, [pc, #16]	; a000b02c <rtems_panic+0x3c>   <== NOT EXECUTED
a000b018:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000b01c:	ebffffd6 	bl	a000af7c <rtems_error>                         <== NOT EXECUTED
  _exit(errno);                                                       
a000b020:	eb002dfb 	bl	a0016814 <__errno>                             <== NOT EXECUTED
a000b024:	e5900000 	ldr	r0, [r0]                                      <== NOT EXECUTED
a000b028:	eb0002bc 	bl	a000bb20 <_exit>                               <== NOT EXECUTED
                                                                      

a0017c8c <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) {
a0017c8c:	e92d47f0 	push	{r4, r5, r6, r7, r8, r9, sl, lr}             <== NOT EXECUTED
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0017c90:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
  uint32_t         length,                                            
  uint32_t         buffer_size,                                       
  rtems_attribute  attribute_set,                                     
  rtems_id        *id                                                 
)                                                                     
{                                                                     
a0017c94:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0017c98:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
a0017c9c:	e59d502c 	ldr	r5, [sp, #44]	; 0x2c                          <== NOT EXECUTED
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a0017ca0:	03a00003 	moveq	r0, #3                                      <== NOT EXECUTED
  rtems_id        *id                                                 
)                                                                     
{                                                                     
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0017ca4:	0a000031 	beq	a0017d70 <rtems_partition_create+0xe4>        <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
a0017ca8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0017cac:	0a000033 	beq	a0017d80 <rtems_partition_create+0xf4>        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
a0017cb0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0017cb4:	0a000031 	beq	a0017d80 <rtems_partition_create+0xf4>        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
a0017cb8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0017cbc:	13530000 	cmpne	r3, #0                                      <== NOT EXECUTED
a0017cc0:	0a00002c 	beq	a0017d78 <rtems_partition_create+0xec>        <== NOT EXECUTED
a0017cc4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0017cc8:	3a00002a 	bcc	a0017d78 <rtems_partition_create+0xec>        <== NOT EXECUTED
a0017ccc:	e3130007 	tst	r3, #7                                        <== NOT EXECUTED
a0017cd0:	1a000028 	bne	a0017d78 <rtems_partition_create+0xec>        <== NOT EXECUTED
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
a0017cd4:	e2118007 	ands	r8, r1, #7                                   <== NOT EXECUTED
a0017cd8:	1a000028 	bne	a0017d80 <rtems_partition_create+0xf4>        <== NOT EXECUTED
a0017cdc:	e59f10b0 	ldr	r1, [pc, #176]	; a0017d94 <rtems_partition_create+0x108><== NOT EXECUTED
a0017ce0:	e5910000 	ldr	r0, [r1]                                      <== NOT EXECUTED
a0017ce4:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a0017ce8:	e5810000 	str	r0, [r1]                                      <== NOT EXECUTED
 *  This function allocates a partition control block from            
 *  the inactive chain of free partition control blocks.              
 */                                                                   
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )  
{                                                                     
  return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
a0017cec:	e59fa0a4 	ldr	sl, [pc, #164]	; a0017d98 <rtems_partition_create+0x10c><== NOT EXECUTED
a0017cf0:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a0017cf4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0017cf8:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0017cfc:	eb001289 	bl	a001c728 <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
a0017d00:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
a0017d04:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
a0017d08:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0017d0c:	0a00001d 	beq	a0017d88 <rtems_partition_create+0xfc>        <== NOT EXECUTED
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
a0017d10:	e59d1028 	ldr	r1, [sp, #40]	; 0x28                          <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
  the_partition->length                = length;                      
a0017d14:	e5872014 	str	r2, [r7, #20]                                 <== NOT EXECUTED
  the_partition->buffer_size           = buffer_size;                 
a0017d18:	e5873018 	str	r3, [r7, #24]                                 <== NOT EXECUTED
  the_partition->attribute_set         = attribute_set;               
a0017d1c:	e587101c 	str	r1, [r7, #28]                                 <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
a0017d20:	e5874010 	str	r4, [r7, #16]                                 <== NOT EXECUTED
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
a0017d24:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
                                                                      
  the_partition->starting_address      = starting_address;            
  the_partition->length                = length;                      
  the_partition->buffer_size           = buffer_size;                 
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
a0017d28:	e5878020 	str	r8, [r7, #32]                                 <== NOT EXECUTED
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
a0017d2c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0017d30:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0017d34:	eb006074 	bl	a002ff0c <__aeabi_uidiv>                       <== NOT EXECUTED
a0017d38:	e2879024 	add	r9, r7, #36	; 0x24                            <== NOT EXECUTED
a0017d3c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0017d40:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017d44:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a0017d48:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0017d4c:	eb000c84 	bl	a001af64 <_Chain_Initialize>                   <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a0017d50:	e5973008 	ldr	r3, [r7, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0017d54:	e59a201c 	ldr	r2, [sl, #28]                                 <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a0017d58:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0017d5c:	e7827721 	str	r7, [r2, r1, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a0017d60:	e587600c 	str	r6, [r7, #12]                                 <== NOT EXECUTED
    &_Partition_Information,                                          
    &the_partition->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_partition->Object.id;                                     
a0017d64:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
a0017d68:	eb001704 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a0017d6c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
}                                                                     
a0017d70:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0017d74:	e8bd87f0 	pop	{r4, r5, r6, r7, r8, r9, sl, pc}              <== NOT EXECUTED
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
a0017d78:	e3a00008 	mov	r0, #8                                        <== NOT EXECUTED
a0017d7c:	eafffffb 	b	a0017d70 <rtems_partition_create+0xe4>          <== NOT EXECUTED
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
     return RTEMS_INVALID_ADDRESS;                                    
a0017d80:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a0017d84:	eafffff9 	b	a0017d70 <rtems_partition_create+0xe4>          <== NOT EXECUTED
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
    _Thread_Enable_dispatch();                                        
a0017d88:	eb0016fc 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a0017d8c:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a0017d90:	eafffff6 	b	a0017d70 <rtems_partition_create+0xe4>          <== NOT EXECUTED
                                                                      

a0017d9c <rtems_partition_delete>: */ rtems_status_code rtems_partition_delete( rtems_id id ) {
a0017d9c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0017da0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017da4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
    _Objects_Get( &_Partition_Information, id, location );            
a0017da8:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017dac:	e59f0054 	ldr	r0, [pc, #84]	; a0017e08 <rtems_partition_delete+0x6c><== NOT EXECUTED
a0017db0:	eb00139f 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017db4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0017db8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0017dbc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017dc0:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017dc4:	1a000004 	bne	a0017ddc <rtems_partition_delete+0x40>        <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( the_partition->number_of_used_blocks == 0 ) {              
a0017dc8:	e5945020 	ldr	r5, [r4, #32]                                 <== NOT EXECUTED
a0017dcc:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0017dd0:	0a000003 	beq	a0017de4 <rtems_partition_delete+0x48>        <== NOT EXECUTED
#endif                                                                
                                                                      
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a0017dd4:	eb0016e9 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_RESOURCE_IN_USE;                                   
a0017dd8:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017ddc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017de0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( the_partition->number_of_used_blocks == 0 ) {              
        _Objects_Close( &_Partition_Information, &the_partition->Object );
a0017de4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017de8:	e59f0018 	ldr	r0, [pc, #24]	; a0017e08 <rtems_partition_delete+0x6c><== NOT EXECUTED
a0017dec:	eb001272 	bl	a001c7bc <_Objects_Close>                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Partition_Free (                           
   Partition_Control *the_partition                                   
)                                                                     
{                                                                     
  _Objects_Free( &_Partition_Information, &the_partition->Object );   
a0017df0:	e59f0010 	ldr	r0, [pc, #16]	; a0017e08 <rtems_partition_delete+0x6c><== NOT EXECUTED
a0017df4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017df8:	eb001324 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
            0                          /* Not used */                 
          );                                                          
        }                                                             
#endif                                                                
                                                                      
        _Thread_Enable_dispatch();                                    
a0017dfc:	eb0016df 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a0017e00:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0017e04:	eafffff4 	b	a0017ddc <rtems_partition_delete+0x40>          <== NOT EXECUTED
                                                                      

a0017e0c <rtems_partition_get_buffer>: rtems_status_code rtems_partition_get_buffer( rtems_id id, void **buffer ) {
a0017e0c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
  void                       *the_buffer;                             
                                                                      
  if ( !buffer )                                                      
a0017e10:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_partition_get_buffer(                         
  rtems_id   id,                                                      
  void     **buffer                                                   
)                                                                     
{                                                                     
a0017e14:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017e18:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
  void                       *the_buffer;                             
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a0017e1c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
  void                       *the_buffer;                             
                                                                      
  if ( !buffer )                                                      
a0017e20:	0a000011 	beq	a0017e6c <rtems_partition_get_buffer+0x60>    <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
    _Objects_Get( &_Partition_Information, id, location );            
a0017e24:	e59f0054 	ldr	r0, [pc, #84]	; a0017e80 <rtems_partition_get_buffer+0x74><== NOT EXECUTED
a0017e28:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017e2c:	eb001380 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017e30:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a0017e34:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0017e38:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017e3c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !buffer )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017e40:	1a000009 	bne	a0017e6c <rtems_partition_get_buffer+0x60>    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (               
   Partition_Control *the_partition                                   
)                                                                     
{                                                                     
  return _Chain_Get( &the_partition->Memory );                        
a0017e44:	e2860024 	add	r0, r6, #36	; 0x24                            <== NOT EXECUTED
a0017e48:	eb000c38 	bl	a001af30 <_Chain_Get>                          <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      the_buffer = _Partition_Allocate_buffer( the_partition );       
      if ( the_buffer ) {                                             
a0017e4c:	e2507000 	subs	r7, r0, #0                                   <== NOT EXECUTED
a0017e50:	0a000007 	beq	a0017e74 <rtems_partition_get_buffer+0x68>    <== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;                    
a0017e54:	e5963020 	ldr	r3, [r6, #32]                                 <== NOT EXECUTED
a0017e58:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0017e5c:	e5863020 	str	r3, [r6, #32]                                 <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a0017e60:	eb0016c6 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        *buffer = the_buffer;                                         
a0017e64:	e5847000 	str	r7, [r4]                                      <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a0017e68:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017e6c:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017e70:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;                    
        _Thread_Enable_dispatch();                                    
        *buffer = the_buffer;                                         
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a0017e74:	eb0016c1 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_UNSATISFIED;                                       
a0017e78:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
a0017e7c:	eafffffa 	b	a0017e6c <rtems_partition_get_buffer+0x60>      <== NOT EXECUTED
                                                                      

a0017e84 <rtems_partition_ident>: rtems_status_code rtems_partition_ident( rtems_name name, uint32_t node, rtems_id *id ) {
a0017e84:	e1a0c001 	mov	ip, r1                                        <== NOT EXECUTED
a0017e88:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0017e8c:	e1a0e000 	mov	lr, r0                                        <== NOT EXECUTED
a0017e90:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32( &_Partition_Information, name, node, id );
a0017e94:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
a0017e98:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a0017e9c:	e59f000c 	ldr	r0, [pc, #12]	; a0017eb0 <rtems_partition_ident+0x2c><== NOT EXECUTED
a0017ea0:	eb0013b8 	bl	a001cd88 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a0017ea4:	e59f3008 	ldr	r3, [pc, #8]	; a0017eb4 <rtems_partition_ident+0x30><== NOT EXECUTED
}                                                                     
a0017ea8:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a0017eac:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0017eb8 <rtems_partition_return_buffer>: rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) {
a0017eb8:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0017ebc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a0017ec0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017ec4:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
    _Objects_Get( &_Partition_Information, id, location );            
a0017ec8:	e59f008c 	ldr	r0, [pc, #140]	; a0017f5c <rtems_partition_return_buffer+0xa4><== NOT EXECUTED
a0017ecc:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0017ed0:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017ed4:	eb001356 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017ed8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0017edc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0017ee0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017ee4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
a0017ee8:	1a000016 	bne	a0017f48 <rtems_partition_return_buffer+0x90> <== NOT EXECUTED
)                                                                     
{                                                                     
  void *starting;                                                     
  void *ending;                                                       
                                                                      
  starting = the_partition->starting_address;                         
a0017eec:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
a0017ef0:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a0017ef4:	e0803003 	add	r3, r0, r3                                    <== NOT EXECUTED
  const void *address,                                                
  const void *base,                                                   
  const void *limit                                                   
)                                                                     
{                                                                     
  return (address >= base && address <= limit);                       
a0017ef8:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a0017efc:	83a03000 	movhi	r3, #0                                      <== NOT EXECUTED
a0017f00:	93a03001 	movls	r3, #1                                      <== NOT EXECUTED
a0017f04:	e1540000 	cmp	r4, r0                                        <== NOT EXECUTED
a0017f08:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
  ending   = _Addresses_Add_offset( starting, the_partition->length );
                                                                      
  return (                                                            
    _Addresses_Is_in_range( the_buffer, starting, ending ) &&         
a0017f0c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0017f10:	0a00000e 	beq	a0017f50 <rtems_partition_return_buffer+0x98> <== NOT EXECUTED
  offset = (uint32_t) _Addresses_Subtract(                            
    the_buffer,                                                       
    the_partition->starting_address                                   
  );                                                                  
                                                                      
  return ((offset % the_partition->buffer_size) == 0);                
a0017f14:	e0600004 	rsb	r0, r0, r4                                    <== NOT EXECUTED
a0017f18:	e5951018 	ldr	r1, [r5, #24]                                 <== NOT EXECUTED
a0017f1c:	eb006040 	bl	a0030024 <__umodsi3>                           <== NOT EXECUTED
                                                                      
  starting = the_partition->starting_address;                         
  ending   = _Addresses_Add_offset( starting, the_partition->length );
                                                                      
  return (                                                            
    _Addresses_Is_in_range( the_buffer, starting, ending ) &&         
a0017f20:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0017f24:	1a000009 	bne	a0017f50 <rtems_partition_return_buffer+0x98> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (                    
  Partition_Control *the_partition,                                   
  Chain_Node        *the_buffer                                       
)                                                                     
{                                                                     
  _Chain_Append( &the_partition->Memory, the_buffer );                
a0017f28:	e2850024 	add	r0, r5, #36	; 0x24                            <== NOT EXECUTED
a0017f2c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0017f30:	eb000beb 	bl	a001aee4 <_Chain_Append>                       <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {    
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
a0017f34:	e5953020 	ldr	r3, [r5, #32]                                 <== NOT EXECUTED
a0017f38:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0017f3c:	e5853020 	str	r3, [r5, #32]                                 <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a0017f40:	eb00168e 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a0017f44:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017f48:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017f4c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a0017f50:	eb00168a 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INVALID_ADDRESS;                                   
a0017f54:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a0017f58:	eafffffa 	b	a0017f48 <rtems_partition_return_buffer+0x90>   <== NOT EXECUTED
                                                                      

a001727c <rtems_port_create>: void *internal_start, void *external_start, uint32_t length, rtems_id *id ) {
a001727c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0017280:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
  void         *internal_start,                                       
  void         *external_start,                                       
  uint32_t      length,                                               
  rtems_id     *id                                                    
)                                                                     
{                                                                     
a0017284:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a0017288:	e59d5020 	ldr	r5, [sp, #32]                                 <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a001728c:	03a00003 	moveq	r0, #3                                      <== NOT EXECUTED
  rtems_id     *id                                                    
)                                                                     
{                                                                     
  register Dual_ported_memory_Control *the_port;                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0017290:	0a000005 	beq	a00172ac <rtems_port_create+0x30>             <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a0017294:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0017298:	0a000002 	beq	a00172a8 <rtems_port_create+0x2c>             <== NOT EXECUTED
 *    id       - port id                                              
 *    RTEMS_SUCCESSFUL - if successful                                
 *    error code - if unsuccessful                                    
 */                                                                   
                                                                      
rtems_status_code rtems_port_create(                                  
a001729c:	e1826001 	orr	r6, r2, r1                                    <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_Addresses_Is_aligned( internal_start ) ||                    
a00172a0:	e2166007 	ands	r6, r6, #7                                   <== NOT EXECUTED
a00172a4:	0a000002 	beq	a00172b4 <rtems_port_create+0x38>             <== NOT EXECUTED
       !_Addresses_Is_aligned( external_start ) )                     
    return RTEMS_INVALID_ADDRESS;                                     
a00172a8:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
  );                                                                  
                                                                      
  *id = the_port->Object.id;                                          
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a00172ac:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a00172b0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a00172b4:	e59f0074 	ldr	r0, [pc, #116]	; a0017330 <rtems_port_create+0xb4><== NOT EXECUTED
a00172b8:	e590c000 	ldr	ip, [r0]                                      <== NOT EXECUTED
a00172bc:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
a00172c0:	e580c000 	str	ip, [r0]                                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control                       
   *_Dual_ported_memory_Allocate ( void )                             
{                                                                     
  return (Dual_ported_memory_Control *)                               
     _Objects_Allocate( &_Dual_ported_memory_Information );           
a00172c4:	e59f7068 	ldr	r7, [pc, #104]	; a0017334 <rtems_port_create+0xb8><== NOT EXECUTED
a00172c8:	e58d1008 	str	r1, [sp, #8]                                  <== NOT EXECUTED
a00172cc:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a00172d0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a00172d4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a00172d8:	eb001512 	bl	a001c728 <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();             /* to prevent deletion */   
                                                                      
  the_port = _Dual_ported_memory_Allocate();                          
                                                                      
  if ( !the_port ) {                                                  
a00172dc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00172e0:	e59d1008 	ldr	r1, [sp, #8]                                  <== NOT EXECUTED
a00172e4:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
a00172e8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a00172ec:	0a00000c 	beq	a0017324 <rtems_port_create+0xa8>             <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a00172f0:	e590c008 	ldr	ip, [r0, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a00172f4:	e597e01c 	ldr	lr, [r7, #28]                                 <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_port->internal_base = internal_start;                           
  the_port->external_base = external_start;                           
  the_port->length        = length - 1;                               
a00172f8:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a00172fc:	e1a0780c 	lsl	r7, ip, #16                                   <== NOT EXECUTED
  if ( !the_port ) {                                                  
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_port->internal_base = internal_start;                           
a0017300:	e5801010 	str	r1, [r0, #16]                                 <== NOT EXECUTED
  the_port->external_base = external_start;                           
a0017304:	e5802014 	str	r2, [r0, #20]                                 <== NOT EXECUTED
  the_port->length        = length - 1;                               
a0017308:	e5803018 	str	r3, [r0, #24]                                 <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a001730c:	e78e0727 	str	r0, [lr, r7, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a0017310:	e580400c 	str	r4, [r0, #12]                                 <== NOT EXECUTED
    &_Dual_ported_memory_Information,                                 
    &the_port->Object,                                                
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_port->Object.id;                                          
a0017314:	e585c000 	str	ip, [r5]                                      <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a0017318:	eb001998 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a001731c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0017320:	eaffffe1 	b	a00172ac <rtems_port_create+0x30>               <== NOT EXECUTED
  _Thread_Disable_dispatch();             /* to prevent deletion */   
                                                                      
  the_port = _Dual_ported_memory_Allocate();                          
                                                                      
  if ( !the_port ) {                                                  
    _Thread_Enable_dispatch();                                        
a0017324:	eb001995 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a0017328:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a001732c:	eaffffde 	b	a00172ac <rtems_port_create+0x30>               <== NOT EXECUTED
                                                                      

a0017338 <rtems_port_delete>: */ rtems_status_code rtems_port_delete( rtems_id id ) {
a0017338:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a001733c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017340:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Dual_ported_memory_Control *)                               
     _Objects_Get( &_Dual_ported_memory_Information, id, location );  
a0017344:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017348:	e59f003c 	ldr	r0, [pc, #60]	; a001738c <rtems_port_delete+0x54><== NOT EXECUTED
a001734c:	eb001638 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a0017350:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a0017354:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0017358:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a001735c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a0017360:	1a000007 	bne	a0017384 <rtems_port_delete+0x4c>             <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
a0017364:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0017368:	e59f001c 	ldr	r0, [pc, #28]	; a001738c <rtems_port_delete+0x54><== NOT EXECUTED
a001736c:	eb001512 	bl	a001c7bc <_Objects_Close>                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free (                  
   Dual_ported_memory_Control *the_port                               
)                                                                     
{                                                                     
  _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
a0017370:	e59f0014 	ldr	r0, [pc, #20]	; a001738c <rtems_port_delete+0x54><== NOT EXECUTED
a0017374:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0017378:	eb0015c4 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
      _Dual_ported_memory_Free( the_port );                           
      _Thread_Enable_dispatch();                                      
a001737c:	eb00197f 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0017380:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017384:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017388:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0017390 <rtems_port_external_to_internal>: rtems_status_code rtems_port_external_to_internal( rtems_id id, void *external, void **internal ) {
a0017390:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !internal )                                                    
a0017394:	e2525000 	subs	r5, r2, #0                                   <== NOT EXECUTED
rtems_status_code rtems_port_external_to_internal(                    
  rtems_id   id,                                                      
  void      *external,                                                
  void     **internal                                                 
)                                                                     
{                                                                     
a0017398:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a001739c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00173a0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !internal )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a00173a4:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !internal )                                                    
a00173a8:	0a000011 	beq	a00173f4 <rtems_port_external_to_internal+0x64><== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Dual_ported_memory_Control *)                               
     _Objects_Get( &_Dual_ported_memory_Information, id, location );  
a00173ac:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a00173b0:	e59f0044 	ldr	r0, [pc, #68]	; a00173fc <rtems_port_external_to_internal+0x6c><== NOT EXECUTED
a00173b4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a00173b8:	eb00161d 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a00173bc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a00173c0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00173c4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !internal )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a00173c8:	1a000009 	bne	a00173f4 <rtems_port_external_to_internal+0x64><== NOT EXECUTED
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (                    
  const void *left,                                                   
  const void *right                                                   
)                                                                     
{                                                                     
  return (int32_t) ((const char *) left - (const char *) right);      
a00173cc:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      ending = _Addresses_Subtract( external, the_port->external_base );
      if ( ending > the_port->length )                                
a00173d0:	e5902018 	ldr	r2, [r0, #24]                                 <== NOT EXECUTED
a00173d4:	e0633004 	rsb	r3, r3, r4                                    <== NOT EXECUTED
a00173d8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (                    
  const void *base,                                                   
  uintptr_t   offset                                                  
)                                                                     
{                                                                     
  return (void *)((uintptr_t)base + offset);                          
a00173dc:	95902010 	ldrls	r2, [r0, #16]                               <== NOT EXECUTED
        *internal = external;                                         
a00173e0:	85854000 	strhi	r4, [r5]                                    <== NOT EXECUTED
a00173e4:	90823003 	addls	r3, r2, r3                                  <== NOT EXECUTED
      else                                                            
        *internal = _Addresses_Add_offset( the_port->internal_base,   
a00173e8:	95853000 	strls	r3, [r5]                                    <== NOT EXECUTED
                                           ending );                  
      _Thread_Enable_dispatch();                                      
a00173ec:	eb001963 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a00173f0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00173f4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00173f8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0017400 <rtems_port_ident>: rtems_status_code rtems_port_ident( rtems_name name, rtems_id *id ) {
a0017400:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0017404:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a0017408:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a001740c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0017410:	e59f0010 	ldr	r0, [pc, #16]	; a0017428 <rtems_port_ident+0x28><== NOT EXECUTED
a0017414:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0017418:	eb00165a 	bl	a001cd88 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_ALL_NODES,                                         
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a001741c:	e59f3008 	ldr	r3, [pc, #8]	; a001742c <rtems_port_ident+0x2c><== NOT EXECUTED
}                                                                     
a0017420:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a0017424:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0017430 <rtems_port_internal_to_external>: rtems_status_code rtems_port_internal_to_external( rtems_id id, void *internal, void **external ) {
a0017430:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !external )                                                    
a0017434:	e2525000 	subs	r5, r2, #0                                   <== NOT EXECUTED
rtems_status_code rtems_port_internal_to_external(                    
  rtems_id   id,                                                      
  void      *internal,                                                
  void     **external                                                 
)                                                                     
{                                                                     
a0017438:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a001743c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017440:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !external )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0017444:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  register Dual_ported_memory_Control *the_port;                      
  Objects_Locations                    location;                      
  uint32_t                             ending;                        
                                                                      
  if ( !external )                                                    
a0017448:	0a000011 	beq	a0017494 <rtems_port_internal_to_external+0x64><== NOT EXECUTED
a001744c:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0017450:	e59f0044 	ldr	r0, [pc, #68]	; a001749c <rtems_port_internal_to_external+0x6c><== NOT EXECUTED
a0017454:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017458:	eb0015f5 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a001745c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0017460:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017464:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !external )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_port = _Dual_ported_memory_Get( id, &location );                
  switch ( location ) {                                               
a0017468:	1a000009 	bne	a0017494 <rtems_port_internal_to_external+0x64><== NOT EXECUTED
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (                    
  const void *left,                                                   
  const void *right                                                   
)                                                                     
{                                                                     
  return (int32_t) ((const char *) left - (const char *) right);      
a001746c:	e5903010 	ldr	r3, [r0, #16]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      ending = _Addresses_Subtract( internal, the_port->internal_base );
      if ( ending > the_port->length )                                
a0017470:	e5902018 	ldr	r2, [r0, #24]                                 <== NOT EXECUTED
a0017474:	e0633004 	rsb	r3, r3, r4                                    <== NOT EXECUTED
a0017478:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (                    
  const void *base,                                                   
  uintptr_t   offset                                                  
)                                                                     
{                                                                     
  return (void *)((uintptr_t)base + offset);                          
a001747c:	95902014 	ldrls	r2, [r0, #20]                               <== NOT EXECUTED
        *external = internal;                                         
a0017480:	85854000 	strhi	r4, [r5]                                    <== NOT EXECUTED
a0017484:	90823003 	addls	r3, r2, r3                                  <== NOT EXECUTED
      else                                                            
        *external = _Addresses_Add_offset( the_port->external_base,   
a0017488:	95853000 	strls	r3, [r5]                                    <== NOT EXECUTED
                                           ending );                  
      _Thread_Enable_dispatch();                                      
a001748c:	eb00193b 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0017490:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017494:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017498:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0005a20 <rtems_print_buffer>: void rtems_print_buffer( const unsigned char *buffer, int length ) {
a0005a20:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
                                                                      
  int i, mod, max;                                                    
                                                                      
  if ( !length ) return;                                              
a0005a24:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
                                                                      
void rtems_print_buffer(                                              
  const unsigned char *buffer,                                        
  int                  length                                         
)                                                                     
{                                                                     
a0005a28:	e24dd084 	sub	sp, sp, #132	; 0x84                           <== NOT EXECUTED
a0005a2c:	e58d0004 	str	r0, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  int i, mod, max;                                                    
                                                                      
  if ( !length ) return;                                              
a0005a30:	0a00003f 	beq	a0005b34 <rtems_print_buffer+0x114>           <== NOT EXECUTED
                                                                      
  mod = length % 16;                                                  
a0005a34:	e1a03fc1 	asr	r3, r1, #31                                   <== NOT EXECUTED
a0005a38:	e1a03e23 	lsr	r3, r3, #28                                   <== NOT EXECUTED
a0005a3c:	e0819003 	add	r9, r1, r3                                    <== NOT EXECUTED
a0005a40:	e209900f 	and	r9, r9, #15                                   <== NOT EXECUTED
a0005a44:	e0639009 	rsb	r9, r3, r9                                    <== NOT EXECUTED
                                                                      
  max = length - mod;                                                 
a0005a48:	e0691001 	rsb	r1, r9, r1                                    <== NOT EXECUTED
                                                                      
  for ( i=0 ; i<max ; i+=16 )                                         
a0005a4c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
                                                                      
  if ( !length ) return;                                              
                                                                      
  mod = length % 16;                                                  
                                                                      
  max = length - mod;                                                 
a0005a50:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
                                                                      
  for ( i=0 ; i<max ; i+=16 )                                         
a0005a54:	da000034 	ble	a0005b2c <rtems_print_buffer+0x10c>           <== NOT EXECUTED
a0005a58:	e59f7238 	ldr	r7, [pc, #568]	; a0005c98 <rtems_print_buffer+0x278><== NOT EXECUTED
a0005a5c:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005a60:	e58d9008 	str	r9, [sp, #8]                                  <== NOT EXECUTED
a0005a64:	e28d400c 	add	r4, sp, #12                                   <== NOT EXECUTED
{                                                                     
                                                                      
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
a0005a68:	e1a0a008 	mov	sl, r8                                        <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005a6c:	e3a0b07c 	mov	fp, #124	; 0x7c                               <== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005a70:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
static inline void Dump_Line(                                         
  const unsigned char *buffer,                                        
  int                  length                                         
);                                                                    
                                                                      
void rtems_print_buffer(                                              
a0005a74:	e0896008 	add	r6, r9, r8                                    <== NOT EXECUTED
{                                                                     
                                                                      
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
a0005a78:	e5cda00c 	strb	sl, [sp, #12]                                <== NOT EXECUTED
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005a7c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
a0005a80:	e7d63005 	ldrb	r3, [r6, r5]                                 <== NOT EXECUTED
a0005a84:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005a88:	e59f120c 	ldr	r1, [pc, #524]	; a0005c9c <rtems_print_buffer+0x27c><== NOT EXECUTED
a0005a8c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005a90:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
a0005a94:	eb0030b6 	bl	a0011d74 <sprintf>                             <== NOT EXECUTED
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005a98:	e3550010 	cmp	r5, #16                                       <== NOT EXECUTED
a0005a9c:	1afffff7 	bne	a0005a80 <rtems_print_buffer+0x60>            <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005aa0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005aa4:	eb0031e9 	bl	a0012250 <strlen>                              <== NOT EXECUTED
a0005aa8:	e0843000 	add	r3, r4, r0                                    <== NOT EXECUTED
a0005aac:	e7c4b000 	strb	fp, [r4, r0]                                 <== NOT EXECUTED
  for( i=0 ; i<length ; i++ )                                         
a0005ab0:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005ab4:	e5c3a001 	strb	sl, [r3, #1]                                 <== NOT EXECUTED
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
a0005ab8:	e7d63005 	ldrb	r3, [r6, r5]                                 <== NOT EXECUTED
a0005abc:	e5972000 	ldr	r2, [r7]                                      <== NOT EXECUTED
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
a0005ac0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005ac4:	e59f11d4 	ldr	r1, [pc, #468]	; a0005ca0 <rtems_print_buffer+0x280><== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
a0005ac8:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
a0005acc:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
a0005ad0:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    sprintf( line_buffer, "%s%c", line_buffer,                        
a0005ad4:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005ad8:	e31c0097 	tst	ip, #151	; 0x97                               <== NOT EXECUTED
a0005adc:	03a0302e 	moveq	r3, #46	; 0x2e                              <== NOT EXECUTED
a0005ae0:	eb0030a3 	bl	a0011d74 <sprintf>                             <== NOT EXECUTED
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
a0005ae4:	e3550010 	cmp	r5, #16                                       <== NOT EXECUTED
a0005ae8:	1afffff2 	bne	a0005ab8 <rtems_print_buffer+0x98>            <== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005aec:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005af0:	eb0031d6 	bl	a0012250 <strlen>                              <== NOT EXECUTED
a0005af4:	e0843000 	add	r3, r4, r0                                    <== NOT EXECUTED
a0005af8:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0005afc:	e7c4b002 	strb	fp, [r4, r2]                                 <== NOT EXECUTED
a0005b00:	e2831002 	add	r1, r3, #2                                    <== NOT EXECUTED
a0005b04:	e3a0200a 	mov	r2, #10                                       <== NOT EXECUTED
a0005b08:	e5c32001 	strb	r2, [r3, #1]                                 <== NOT EXECUTED
                                                                      
  printk( line_buffer );                                              
a0005b0c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005b10:	e5c1a000 	strb	sl, [r1]                                     <== NOT EXECUTED
                                                                      
  printk( line_buffer );                                              
a0005b14:	eb00065c 	bl	a000748c <printk>                              <== NOT EXECUTED
                                                                      
  mod = length % 16;                                                  
                                                                      
  max = length - mod;                                                 
                                                                      
  for ( i=0 ; i<max ; i+=16 )                                         
a0005b18:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0005b1c:	e2888010 	add	r8, r8, #16                                   <== NOT EXECUTED
a0005b20:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
a0005b24:	caffffd2 	bgt	a0005a74 <rtems_print_buffer+0x54>            <== NOT EXECUTED
a0005b28:	e59d9008 	ldr	r9, [sp, #8]                                  <== NOT EXECUTED
    Dump_Line( &buffer[ i ], 16 );                                    
                                                                      
  if ( mod )                                                          
a0005b2c:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a0005b30:	1a000001 	bne	a0005b3c <rtems_print_buffer+0x11c>           <== NOT EXECUTED
    Dump_Line( &buffer[ max ], mod );                                 
}                                                                     
a0005b34:	e28dd084 	add	sp, sp, #132	; 0x84                           <== NOT EXECUTED
a0005b38:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
  for ( i=0 ; i<max ; i+=16 )                                         
    Dump_Line( &buffer[ i ], 16 );                                    
                                                                      
  if ( mod )                                                          
    Dump_Line( &buffer[ max ], mod );                                 
a0005b3c:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
a0005b40:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
{                                                                     
                                                                      
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
a0005b44:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a0005b48:	e5cd500c 	strb	r5, [sp, #12]                                <== NOT EXECUTED
                                                                      
  for ( i=0 ; i<max ; i+=16 )                                         
    Dump_Line( &buffer[ i ], 16 );                                    
                                                                      
  if ( mod )                                                          
    Dump_Line( &buffer[ max ], mod );                                 
a0005b4c:	e0826003 	add	r6, r2, r3                                    <== NOT EXECUTED
a0005b50:	d28d400c 	addle	r4, sp, #12                                 <== NOT EXECUTED
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005b54:	da00000b 	ble	a0005b88 <rtems_print_buffer+0x168>           <== NOT EXECUTED
a0005b58:	e28d400c 	add	r4, sp, #12                                   <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
a0005b5c:	e7d63005 	ldrb	r3, [r6, r5]                                 <== NOT EXECUTED
a0005b60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005b64:	e59f1130 	ldr	r1, [pc, #304]	; a0005c9c <rtems_print_buffer+0x27c><== NOT EXECUTED
a0005b68:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005b6c:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
a0005b70:	eb00307f 	bl	a0011d74 <sprintf>                             <== NOT EXECUTED
  int  i;                                                             
  char line_buffer[120];                                              
                                                                      
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
a0005b74:	e1590005 	cmp	r9, r5                                        <== NOT EXECUTED
a0005b78:	cafffff7 	bgt	a0005b5c <rtems_print_buffer+0x13c>           <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005b7c:	e359000f 	cmp	r9, #15                                       <== NOT EXECUTED
a0005b80:	d1a05009 	movle	r5, r9                                      <== NOT EXECUTED
a0005b84:	ca00003b 	bgt	a0005c78 <rtems_print_buffer+0x258>           <== NOT EXECUTED
    strcat( line_buffer, "   " );                                     
a0005b88:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005b8c:	eb0031af 	bl	a0012250 <strlen>                              <== NOT EXECUTED
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005b90:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    strcat( line_buffer, "   " );                                     
a0005b94:	e59f1108 	ldr	r1, [pc, #264]	; a0005ca4 <rtems_print_buffer+0x284><== NOT EXECUTED
a0005b98:	e0840000 	add	r0, r4, r0                                    <== NOT EXECUTED
a0005b9c:	e3a02004 	mov	r2, #4                                        <== NOT EXECUTED
a0005ba0:	eb002fe2 	bl	a0011b30 <memcpy>                              <== NOT EXECUTED
  line_buffer[0] = '\0';                                              
                                                                      
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005ba4:	e355000f 	cmp	r5, #15                                       <== NOT EXECUTED
a0005ba8:	dafffff6 	ble	a0005b88 <rtems_print_buffer+0x168>           <== NOT EXECUTED
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005bac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005bb0:	eb0031a6 	bl	a0012250 <strlen>                              <== NOT EXECUTED
a0005bb4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0005bb8:	e0842000 	add	r2, r4, r0                                    <== NOT EXECUTED
  for( i=0 ; i<length ; i++ )                                         
a0005bbc:	e1590003 	cmp	r9, r3                                        <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005bc0:	e3a0107c 	mov	r1, #124	; 0x7c                               <== NOT EXECUTED
a0005bc4:	e7c41000 	strb	r1, [r4, r0]                                 <== NOT EXECUTED
  for( i=0 ; i<length ; i++ )                                         
a0005bc8:	d1a09003 	movle	r9, r3                                      <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005bcc:	e5c23001 	strb	r3, [r2, #1]                                 <== NOT EXECUTED
  for( i=0 ; i<length ; i++ )                                         
a0005bd0:	da000010 	ble	a0005c18 <rtems_print_buffer+0x1f8>           <== NOT EXECUTED
a0005bd4:	e59f70bc 	ldr	r7, [pc, #188]	; a0005c98 <rtems_print_buffer+0x278><== NOT EXECUTED
a0005bd8:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
a0005bdc:	e7d63005 	ldrb	r3, [r6, r5]                                 <== NOT EXECUTED
a0005be0:	e5972000 	ldr	r2, [r7]                                      <== NOT EXECUTED
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
a0005be4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005be8:	e59f10b0 	ldr	r1, [pc, #176]	; a0005ca0 <rtems_print_buffer+0x280><== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
a0005bec:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
a0005bf0:	e5d2c001 	ldrb	ip, [r2, #1]                                 <== NOT EXECUTED
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
a0005bf4:	e2855001 	add	r5, r5, #1                                    <== NOT EXECUTED
    sprintf( line_buffer, "%s%c", line_buffer,                        
a0005bf8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0005bfc:	e31c0097 	tst	ip, #151	; 0x97                               <== NOT EXECUTED
a0005c00:	03a0302e 	moveq	r3, #46	; 0x2e                              <== NOT EXECUTED
a0005c04:	eb00305a 	bl	a0011d74 <sprintf>                             <== NOT EXECUTED
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
a0005c08:	e1590005 	cmp	r9, r5                                        <== NOT EXECUTED
a0005c0c:	cafffff2 	bgt	a0005bdc <rtems_print_buffer+0x1bc>           <== NOT EXECUTED
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005c10:	e359000f 	cmp	r9, #15                                       <== NOT EXECUTED
a0005c14:	ca000009 	bgt	a0005c40 <rtems_print_buffer+0x220>           <== NOT EXECUTED
    strcat( line_buffer, " " );                                       
a0005c18:	e3a06020 	mov	r6, #32                                       <== NOT EXECUTED
a0005c1c:	e3a05000 	mov	r5, #0                                        <== NOT EXECUTED
a0005c20:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005c24:	eb003189 	bl	a0012250 <strlen>                              <== NOT EXECUTED
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005c28:	e2899001 	add	r9, r9, #1                                    <== NOT EXECUTED
    strcat( line_buffer, " " );                                       
a0005c2c:	e0843000 	add	r3, r4, r0                                    <== NOT EXECUTED
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005c30:	e359000f 	cmp	r9, #15                                       <== NOT EXECUTED
    strcat( line_buffer, " " );                                       
a0005c34:	e7c46000 	strb	r6, [r4, r0]                                 <== NOT EXECUTED
a0005c38:	e5c35001 	strb	r5, [r3, #1]                                 <== NOT EXECUTED
  strcat( line_buffer, "|" );                                         
  for( i=0 ; i<length ; i++ )                                         
    sprintf( line_buffer, "%s%c", line_buffer,                        
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
a0005c3c:	dafffff7 	ble	a0005c20 <rtems_print_buffer+0x200>           <== NOT EXECUTED
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005c40:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005c44:	eb003181 	bl	a0012250 <strlen>                              <== NOT EXECUTED
a0005c48:	e3a0c07c 	mov	ip, #124	; 0x7c                               <== NOT EXECUTED
a0005c4c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0005c50:	e0843000 	add	r3, r4, r0                                    <== NOT EXECUTED
a0005c54:	e7c4c002 	strb	ip, [r4, r2]                                 <== NOT EXECUTED
a0005c58:	e3a0200a 	mov	r2, #10                                       <== NOT EXECUTED
a0005c5c:	e2831002 	add	r1, r3, #2                                    <== NOT EXECUTED
a0005c60:	e5c32001 	strb	r2, [r3, #1]                                 <== NOT EXECUTED
a0005c64:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
                                                                      
  printk( line_buffer );                                              
a0005c68:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
             isprint( buffer[ i ] ) ? buffer[ i ] : '.' );            
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, " " );                                       
                                                                      
  strcat( line_buffer, "|\n" );                                       
a0005c6c:	e5c13000 	strb	r3, [r1]                                     <== NOT EXECUTED
                                                                      
  printk( line_buffer );                                              
a0005c70:	eb000605 	bl	a000748c <printk>                              <== NOT EXECUTED
a0005c74:	eaffffae 	b	a0005b34 <rtems_print_buffer+0x114>             <== NOT EXECUTED
    sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );      
                                                                      
  for( ; i<16 ; i++ )                                                 
    strcat( line_buffer, "   " );                                     
                                                                      
  strcat( line_buffer, "|" );                                         
a0005c78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0005c7c:	eb003173 	bl	a0012250 <strlen>                              <== NOT EXECUTED
a0005c80:	e3a0207c 	mov	r2, #124	; 0x7c                               <== NOT EXECUTED
a0005c84:	e7c42000 	strb	r2, [r4, r0]                                 <== NOT EXECUTED
a0005c88:	e0843000 	add	r3, r4, r0                                    <== NOT EXECUTED
a0005c8c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0005c90:	e5c32001 	strb	r2, [r3, #1]                                 <== NOT EXECUTED
a0005c94:	eaffffce 	b	a0005bd4 <rtems_print_buffer+0x1b4>             <== NOT EXECUTED
                                                                      

a0017f60 <rtems_rate_monotonic_cancel>: */ rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) {
a0017f60:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0017f64:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0017f68:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Rate_monotonic_Control *)                                   
    _Objects_Get( &_Rate_monotonic_Information, id, location );       
a0017f6c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0017f70:	e59f0050 	ldr	r0, [pc, #80]	; a0017fc8 <rtems_rate_monotonic_cancel+0x68><== NOT EXECUTED
a0017f74:	eb00132e 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  Rate_monotonic_Control *the_period;                                 
  Objects_Locations       location;                                   
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0017f78:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a0017f7c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0017f80:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0017f84:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Rate_monotonic_Control *the_period;                                 
  Objects_Locations       location;                                   
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0017f88:	1a000006 	bne	a0017fa8 <rtems_rate_monotonic_cancel+0x48>   <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
a0017f8c:	e59f3038 	ldr	r3, [pc, #56]	; a0017fcc <rtems_rate_monotonic_cancel+0x6c><== NOT EXECUTED
a0017f90:	e5952040 	ldr	r2, [r5, #64]	; 0x40                          <== NOT EXECUTED
a0017f94:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0017f98:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0017f9c:	0a000003 	beq	a0017fb0 <rtems_rate_monotonic_cancel+0x50>   <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a0017fa0:	eb001676 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
a0017fa4:	e3a00017 	mov	r0, #23                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0017fa8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0017fac:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
        _Thread_Enable_dispatch();                                    
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
      (void) _Watchdog_Remove( &the_period->Timer );                  
a0017fb0:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
a0017fb4:	eb001b02 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;                    
a0017fb8:	e5854038 	str	r4, [r5, #56]	; 0x38                          <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0017fbc:	eb00166f 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0017fc0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0017fc4:	eafffff7 	b	a0017fa8 <rtems_rate_monotonic_cancel+0x48>     <== NOT EXECUTED
                                                                      

a000a878 <rtems_rate_monotonic_create>: rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) {
a000a878:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Rate_monotonic_Control *the_period;                                 
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000a87c:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_rate_monotonic_create(                        
  rtems_name  name,                                                   
  rtems_id   *id                                                      
)                                                                     
{                                                                     
a000a880:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  Rate_monotonic_Control *the_period;                                 
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000a884:	0a00002b 	beq	a000a938 <rtems_rate_monotonic_create+0xc0>   <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a000a888:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000a88c:	0a00002e 	beq	a000a94c <rtems_rate_monotonic_create+0xd4>   <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000a890:	e59f30bc 	ldr	r3, [pc, #188]	; a000a954 <rtems_rate_monotonic_create+0xdc><== NOT EXECUTED
a000a894:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000a898:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a89c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
 *  the inactive chain of free period control blocks.                 
 */                                                                   
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{                                                                     
  return (Rate_monotonic_Control *)                                   
    _Objects_Allocate( &_Rate_monotonic_Information );                
a000a8a0:	e59f60b0 	ldr	r6, [pc, #176]	; a000a958 <rtems_rate_monotonic_create+0xe0><== NOT EXECUTED
a000a8a4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a8a8:	eb00080d 	bl	a000c8e4 <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();            /* to prevent deletion */    
                                                                      
  the_period = _Rate_monotonic_Allocate();                            
                                                                      
  if ( !the_period ) {                                                
a000a8ac:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a8b0:	0a000022 	beq	a000a940 <rtems_rate_monotonic_create+0xc8>   <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_period->owner = _Thread_Executing;                              
a000a8b4:	e59f30a0 	ldr	r3, [pc, #160]	; a000a95c <rtems_rate_monotonic_create+0xe4><== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a000a8b8:	e5902008 	ldr	r2, [r0, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000a8bc:	e596101c 	ldr	r1, [r6, #28]                                 <== NOT EXECUTED
a000a8c0:	e593e004 	ldr	lr, [r3, #4]                                  <== NOT EXECUTED
  the_period->state = RATE_MONOTONIC_INACTIVE;                        
a000a8c4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
                                                                      
  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );          
                                                                      
  _Rate_monotonic_Reset_statistics( the_period );                     
a000a8c8:	e3e03102 	mvn	r3, #-2147483648	; 0x80000000                 <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a000a8cc:	e1a0c802 	lsl	ip, r2, #16                                   <== NOT EXECUTED
  if ( !the_period ) {                                                
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_period->owner = _Thread_Executing;                              
a000a8d0:	e580e040 	str	lr, [r0, #64]	; 0x40                          <== NOT EXECUTED
  the_period->state = RATE_MONOTONIC_INACTIVE;                        
a000a8d4:	e5806038 	str	r6, [r0, #56]	; 0x38                          <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000a8d8:	e5806018 	str	r6, [r0, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a000a8dc:	e580602c 	str	r6, [r0, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a000a8e0:	e5806030 	str	r6, [r0, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a000a8e4:	e5806034 	str	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );          
                                                                      
  _Rate_monotonic_Reset_statistics( the_period );                     
a000a8e8:	e5806054 	str	r6, [r0, #84]	; 0x54                          <== NOT EXECUTED
a000a8ec:	e5806058 	str	r6, [r0, #88]	; 0x58                          <== NOT EXECUTED
a000a8f0:	e5806064 	str	r6, [r0, #100]	; 0x64                         <== NOT EXECUTED
a000a8f4:	e5806068 	str	r6, [r0, #104]	; 0x68                         <== NOT EXECUTED
a000a8f8:	e580606c 	str	r6, [r0, #108]	; 0x6c                         <== NOT EXECUTED
a000a8fc:	e5806070 	str	r6, [r0, #112]	; 0x70                         <== NOT EXECUTED
a000a900:	e580607c 	str	r6, [r0, #124]	; 0x7c                         <== NOT EXECUTED
a000a904:	e5806080 	str	r6, [r0, #128]	; 0x80                         <== NOT EXECUTED
a000a908:	e5806084 	str	r6, [r0, #132]	; 0x84                         <== NOT EXECUTED
a000a90c:	e5806088 	str	r6, [r0, #136]	; 0x88                         <== NOT EXECUTED
a000a910:	e580305c 	str	r3, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a000a914:	e5803060 	str	r3, [r0, #96]	; 0x60                          <== NOT EXECUTED
a000a918:	e5803074 	str	r3, [r0, #116]	; 0x74                         <== NOT EXECUTED
a000a91c:	e5803078 	str	r3, [r0, #120]	; 0x78                         <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000a920:	e781072c 	str	r0, [r1, ip, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a000a924:	e580400c 	str	r4, [r0, #12]                                 <== NOT EXECUTED
    &_Rate_monotonic_Information,                                     
    &the_period->Object,                                              
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_period->Object.id;                                        
a000a928:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a000a92c:	eb000cb3 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a000a930:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a934:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
)                                                                     
{                                                                     
  Rate_monotonic_Control *the_period;                                 
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a000a938:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
a000a93c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  _Thread_Disable_dispatch();            /* to prevent deletion */    
                                                                      
  the_period = _Rate_monotonic_Allocate();                            
                                                                      
  if ( !the_period ) {                                                
    _Thread_Enable_dispatch();                                        
a000a940:	eb000cae 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a000a944:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a000a948:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
a000a94c:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
  );                                                                  
                                                                      
  *id = the_period->Object.id;                                        
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000a950:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a00180b8 <rtems_rate_monotonic_delete>: */ rtems_status_code rtems_rate_monotonic_delete( rtems_id id ) {
a00180b8:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a00180bc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00180c0:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Rate_monotonic_Control *)                                   
    _Objects_Get( &_Rate_monotonic_Information, id, location );       
a00180c4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a00180c8:	e59f0048 	ldr	r0, [pc, #72]	; a0018118 <rtems_rate_monotonic_delete+0x60><== NOT EXECUTED
a00180cc:	eb0012d8 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  Rate_monotonic_Control *the_period;                                 
  Objects_Locations       location;                                   
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a00180d0:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a00180d4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a00180d8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00180dc:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Rate_monotonic_Control *the_period;                                 
  Objects_Locations       location;                                   
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a00180e0:	1a00000a 	bne	a0018110 <rtems_rate_monotonic_delete+0x58>   <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
a00180e4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00180e8:	e59f0028 	ldr	r0, [pc, #40]	; a0018118 <rtems_rate_monotonic_delete+0x60><== NOT EXECUTED
a00180ec:	eb0011b2 	bl	a001c7bc <_Objects_Close>                      <== NOT EXECUTED
      (void) _Watchdog_Remove( &the_period->Timer );                  
a00180f0:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
a00180f4:	eb001ab2 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Rate_monotonic_Free (                      
  Rate_monotonic_Control *the_period                                  
)                                                                     
{                                                                     
  _Objects_Free( &_Rate_monotonic_Information, &the_period->Object ); 
a00180f8:	e59f0018 	ldr	r0, [pc, #24]	; a0018118 <rtems_rate_monotonic_delete+0x60><== NOT EXECUTED
a00180fc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;                    
a0018100:	e5854038 	str	r4, [r5, #56]	; 0x38                          <== NOT EXECUTED
a0018104:	eb001261 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
      _Rate_monotonic_Free( the_period );                             
      _Thread_Enable_dispatch();                                      
a0018108:	eb00161c 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a001810c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0018110:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0018114:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0010a28 <rtems_rate_monotonic_get_statistics>: rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *statistics ) {
a0010a28:	e92d4bf0 	push	{r4, r5, r6, r7, r8, r9, fp, lr}             <== NOT EXECUTED
  Objects_Locations                        location;                  
  Rate_monotonic_Control                  *the_period;                
  rtems_rate_monotonic_period_statistics  *dst;                       
  Rate_monotonic_Statistics               *src;                       
                                                                      
  if ( !statistics )                                                  
a0010a2c:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_rate_monotonic_get_statistics(                
  rtems_id                                id,                         
  rtems_rate_monotonic_period_statistics *statistics                  
)                                                                     
{                                                                     
a0010a30:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010a34:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Rate_monotonic_Control                  *the_period;                
  rtems_rate_monotonic_period_statistics  *dst;                       
  Rate_monotonic_Statistics               *src;                       
                                                                      
  if ( !statistics )                                                  
    return RTEMS_INVALID_ADDRESS;                                     
a0010a38:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  Objects_Locations                        location;                  
  Rate_monotonic_Control                  *the_period;                
  rtems_rate_monotonic_period_statistics  *dst;                       
  Rate_monotonic_Statistics               *src;                       
                                                                      
  if ( !statistics )                                                  
a0010a3c:	0a000024 	beq	a0010ad4 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
a0010a40:	e59f0094 	ldr	r0, [pc, #148]	; a0010adc <rtems_rate_monotonic_get_statistics+0xb4><== NOT EXECUTED
a0010a44:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0010a48:	ebfff119 	bl	a000ceb4 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0010a4c:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a0010a50:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0010a54:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !statistics )                                                  
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0010a58:	1a00001d 	bne	a0010ad4 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      dst = statistics;                                               
      src = &the_period->Statistics;                                  
      dst->count        = src->count;                                 
a0010a5c:	e590e054 	ldr	lr, [r0, #84]	; 0x54                          <== NOT EXECUTED
      dst->missed_count = src->missed_count;                          
a0010a60:	e5901058 	ldr	r1, [r0, #88]	; 0x58                          <== NOT EXECUTED
      #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                      
        _Timestamp_To_timespec( &src->min_cpu_time,   &dst->min_cpu_time );
        _Timestamp_To_timespec( &src->max_cpu_time,   &dst->max_cpu_time );
        _Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
        _Timestamp_To_timespec( &src->min_wall_time,   &dst->min_wall_time );
a0010a64:	e2803074 	add	r3, r0, #116	; 0x74                           <== NOT EXECUTED
a0010a68:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
      dst = statistics;                                               
      src = &the_period->Statistics;                                  
      dst->count        = src->count;                                 
      dst->missed_count = src->missed_count;                          
      #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                      
        _Timestamp_To_timespec( &src->min_cpu_time,   &dst->min_cpu_time );
a0010a6c:	e280905c 	add	r9, r0, #92	; 0x5c                            <== NOT EXECUTED
a0010a70:	e8990300 	ldm	r9, {r8, r9}                                  <== NOT EXECUTED
        _Timestamp_To_timespec( &src->max_cpu_time,   &dst->max_cpu_time );
a0010a74:	e2807064 	add	r7, r0, #100	; 0x64                           <== NOT EXECUTED
a0010a78:	e89700c0 	ldm	r7, {r6, r7}                                  <== NOT EXECUTED
        _Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
a0010a7c:	e280c06c 	add	ip, r0, #108	; 0x6c                           <== NOT EXECUTED
a0010a80:	e89c1800 	ldm	ip, {fp, ip}                                  <== NOT EXECUTED
        _Timestamp_To_timespec( &src->min_wall_time,   &dst->min_wall_time );
a0010a84:	e5842020 	str	r2, [r4, #32]                                 <== NOT EXECUTED
a0010a88:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
        _Timestamp_To_timespec( &src->max_wall_time,   &dst->max_wall_time );
a0010a8c:	e280307c 	add	r3, r0, #124	; 0x7c                           <== NOT EXECUTED
a0010a90:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0010a94:	e5842028 	str	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
a0010a98:	e584302c 	str	r3, [r4, #44]	; 0x2c                          <== NOT EXECUTED
        _Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
a0010a9c:	e2803084 	add	r3, r0, #132	; 0x84                           <== NOT EXECUTED
a0010aa0:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      dst = statistics;                                               
      src = &the_period->Statistics;                                  
      dst->count        = src->count;                                 
a0010aa4:	e584e000 	str	lr, [r4]                                      <== NOT EXECUTED
        _Timestamp_To_timespec( &src->min_cpu_time,   &dst->min_cpu_time );
        _Timestamp_To_timespec( &src->max_cpu_time,   &dst->max_cpu_time );
        _Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
        _Timestamp_To_timespec( &src->min_wall_time,   &dst->min_wall_time );
        _Timestamp_To_timespec( &src->max_wall_time,   &dst->max_wall_time );
        _Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
a0010aa8:	e5842030 	str	r2, [r4, #48]	; 0x30                          <== NOT EXECUTED
a0010aac:	e5843034 	str	r3, [r4, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      dst = statistics;                                               
      src = &the_period->Statistics;                                  
      dst->count        = src->count;                                 
      dst->missed_count = src->missed_count;                          
a0010ab0:	e5841004 	str	r1, [r4, #4]                                  <== NOT EXECUTED
      #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                      
        _Timestamp_To_timespec( &src->min_cpu_time,   &dst->min_cpu_time );
a0010ab4:	e5848008 	str	r8, [r4, #8]                                  <== NOT EXECUTED
a0010ab8:	e584900c 	str	r9, [r4, #12]                                 <== NOT EXECUTED
        _Timestamp_To_timespec( &src->max_cpu_time,   &dst->max_cpu_time );
a0010abc:	e5846010 	str	r6, [r4, #16]                                 <== NOT EXECUTED
a0010ac0:	e5847014 	str	r7, [r4, #20]                                 <== NOT EXECUTED
        _Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
a0010ac4:	e584b018 	str	fp, [r4, #24]                                 <== NOT EXECUTED
a0010ac8:	e584c01c 	str	ip, [r4, #28]                                 <== NOT EXECUTED
        dst->min_wall_time   = src->min_wall_time;                    
        dst->max_wall_time   = src->max_wall_time;                    
        dst->total_wall_time = src->total_wall_time;                  
      #endif                                                          
                                                                      
      _Thread_Enable_dispatch();                                      
a0010acc:	ebfff44b 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0010ad0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0010ad4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0010ad8:	e8bd8bf0 	pop	{r4, r5, r6, r7, r8, r9, fp, pc}              <== NOT EXECUTED
                                                                      

a0010ae0 <rtems_rate_monotonic_get_status>: rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) {
a0010ae0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  Objects_Locations              location;                            
  Rate_monotonic_Period_time_t   since_last_period;                   
  Rate_monotonic_Control        *the_period;                          
  bool                           valid_status;                        
                                                                      
  if ( !status )                                                      
a0010ae4:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_rate_monotonic_get_status(                    
  rtems_id                            id,                             
  rtems_rate_monotonic_period_status *status                          
)                                                                     
{                                                                     
a0010ae8:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
a0010aec:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Rate_monotonic_Period_time_t   since_last_period;                   
  Rate_monotonic_Control        *the_period;                          
  bool                           valid_status;                        
                                                                      
  if ( !status )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a0010af0:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  Objects_Locations              location;                            
  Rate_monotonic_Period_time_t   since_last_period;                   
  Rate_monotonic_Control        *the_period;                          
  bool                           valid_status;                        
                                                                      
  if ( !status )                                                      
a0010af4:	0a000013 	beq	a0010b48 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED
a0010af8:	e28d2010 	add	r2, sp, #16                                   <== NOT EXECUTED
a0010afc:	e59f008c 	ldr	r0, [pc, #140]	; a0010b90 <rtems_rate_monotonic_get_status+0xb0><== NOT EXECUTED
a0010b00:	ebfff0eb 	bl	a000ceb4 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0010b04:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
a0010b08:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a0010b0c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0010b10:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !status )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a0010b14:	1a00000b 	bne	a0010b48 <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      status->owner = the_period->owner->Object.id;                   
a0010b18:	e5932040 	ldr	r2, [r3, #64]	; 0x40                          <== NOT EXECUTED
      status->state = the_period->state;                              
a0010b1c:	e5933038 	ldr	r3, [r3, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      status->owner = the_period->owner->Object.id;                   
a0010b20:	e5922008 	ldr	r2, [r2, #8]                                  <== NOT EXECUTED
      status->state = the_period->state;                              
                                                                      
      /*                                                              
       *  If the period is inactive, there is no information.         
       */                                                             
      if ( status->state == RATE_MONOTONIC_INACTIVE ) {               
a0010b24:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      status->owner = the_period->owner->Object.id;                   
      status->state = the_period->state;                              
a0010b28:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
                                                                      
      /*                                                              
       *  If the period is inactive, there is no information.         
       */                                                             
      if ( status->state == RATE_MONOTONIC_INACTIVE ) {               
a0010b2c:	1a000007 	bne	a0010b50 <rtems_rate_monotonic_get_status+0x70><== NOT EXECUTED
        #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                    
          _Timespec_Set_to_zero( &status->since_last_period );        
a0010b30:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
a0010b34:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
          _Timespec_Set_to_zero( &status->executed_since_last_period );
a0010b38:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
a0010b3c:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
          status->since_last_period = since_last_period;              
          status->executed_since_last_period = executed;              
        #endif                                                        
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
a0010b40:	ebfff42e 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0010b44:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0010b48:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a0010b4c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
      } else {                                                        
                                                                      
        /*                                                            
         *  Grab the current status.                                  
         */                                                           
        valid_status =                                                
a0010b50:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010b54:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a0010b58:	ebffe78c 	bl	a000a990 <_Rate_monotonic_Get_status>          <== NOT EXECUTED
          _Rate_monotonic_Get_status(                                 
            the_period, &since_last_period, &executed                 
          );                                                          
        if (!valid_status) {                                          
a0010b5c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010b60:	0a000007 	beq	a0010b84 <rtems_rate_monotonic_get_status+0xa4><== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
          return RTEMS_NOT_DEFINED;                                   
        }                                                             
                                                                      
        #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                    
          _Timestamp_To_timespec(                                     
a0010b64:	e89d000c 	ldm	sp, {r2, r3}                                  <== NOT EXECUTED
a0010b68:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
a0010b6c:	e584300c 	str	r3, [r4, #12]                                 <== NOT EXECUTED
            &since_last_period, &status->since_last_period            
          );                                                          
          _Timestamp_To_timespec(                                     
a0010b70:	e28d3008 	add	r3, sp, #8                                    <== NOT EXECUTED
a0010b74:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0010b78:	e5842010 	str	r2, [r4, #16]                                 <== NOT EXECUTED
a0010b7c:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
a0010b80:	eaffffee 	b	a0010b40 <rtems_rate_monotonic_get_status+0x60> <== NOT EXECUTED
        valid_status =                                                
          _Rate_monotonic_Get_status(                                 
            the_period, &since_last_period, &executed                 
          );                                                          
        if (!valid_status) {                                          
          _Thread_Enable_dispatch();                                  
a0010b84:	ebfff41d 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_NOT_DEFINED;                                   
a0010b88:	e3a0000b 	mov	r0, #11                                       <== NOT EXECUTED
a0010b8c:	eaffffed 	b	a0010b48 <rtems_rate_monotonic_get_status+0x68> <== NOT EXECUTED
                                                                      

a000a960 <rtems_rate_monotonic_ident>: rtems_status_code rtems_rate_monotonic_ident( rtems_name name, rtems_id *id ) {
a000a960:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000a964:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a000a968:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a000a96c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a000a970:	e59f0010 	ldr	r0, [pc, #16]	; a000a988 <rtems_rate_monotonic_ident+0x28><== NOT EXECUTED
a000a974:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a000a978:	eb0009a2 	bl	a000d008 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_LOCAL_NODE,                                        
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a000a97c:	e59f3008 	ldr	r3, [pc, #8]	; a000a98c <rtems_rate_monotonic_ident+0x2c><== NOT EXECUTED
}                                                                     
a000a980:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a000a984:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000abbc <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) {
a000abbc:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a000abc0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000abc4:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a000abc8:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Rate_monotonic_Control *)                                   
    _Objects_Get( &_Rate_monotonic_Information, id, location );       
a000abcc:	e59f017c 	ldr	r0, [pc, #380]	; a000ad50 <rtems_rate_monotonic_period+0x194><== NOT EXECUTED
a000abd0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000abd4:	e28d2004 	add	r2, sp, #4                                    <== NOT EXECUTED
a000abd8:	eb0008b5 	bl	a000ceb4 <_Objects_Get>                        <== NOT EXECUTED
  rtems_rate_monotonic_period_states   local_state;                   
  ISR_Level                            level;                         
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
                                                                      
  switch ( location ) {                                               
a000abdc:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a000abe0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a000abe4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000abe8:	1a000008 	bne	a000ac10 <rtems_rate_monotonic_period+0x54>   <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
a000abec:	e59f7160 	ldr	r7, [pc, #352]	; a000ad54 <rtems_rate_monotonic_period+0x198><== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
a000abf0:	e5902040 	ldr	r2, [r0, #64]	; 0x40                          <== NOT EXECUTED
a000abf4:	e5973004 	ldr	r3, [r7, #4]                                  <== NOT EXECUTED
a000abf8:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000abfc:	0a000005 	beq	a000ac18 <rtems_rate_monotonic_period+0x5c>   <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a000ac00:	eb000bfe 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
a000ac04:	e3a00017 	mov	r0, #23                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000ac08:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000ac0c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000ac10:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
a000ac14:	eafffffb 	b	a000ac08 <rtems_rate_monotonic_period+0x4c>     <== NOT EXECUTED
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
        _Thread_Enable_dispatch();                                    
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
a000ac18:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000ac1c:	1a000008 	bne	a000ac44 <rtems_rate_monotonic_period+0x88>   <== NOT EXECUTED
        switch ( the_period->state ) {                                
a000ac20:	e5903038 	ldr	r3, [r0, #56]	; 0x38                          <== NOT EXECUTED
a000ac24:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a000ac28:	959f2128 	ldrls	r2, [pc, #296]	; a000ad58 <rtems_rate_monotonic_period+0x19c><== NOT EXECUTED
a000ac2c:	81a00005 	movhi	r0, r5                                      <== NOT EXECUTED
a000ac30:	97920103 	ldrls	r0, [r2, r3, lsl #2]                        <== NOT EXECUTED
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
        the_period->next_length = length;                             
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
a000ac34:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
a000ac38:	eb000bf0 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_TIMEOUT;                                         
a000ac3c:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a000ac40:	eafffff0 	b	a000ac08 <rtems_rate_monotonic_period+0x4c>     <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000ac44:	e10f8000 	mrs	r8, CPSR                                      <== NOT EXECUTED
a000ac48:	e3883080 	orr	r3, r8, #128	; 0x80                           <== NOT EXECUTED
a000ac4c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
a000ac50:	e5903038 	ldr	r3, [r0, #56]	; 0x38                          <== NOT EXECUTED
a000ac54:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ac58:	0a00000e 	beq	a000ac98 <rtems_rate_monotonic_period+0xdc>   <== NOT EXECUTED
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
a000ac5c:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a000ac60:	0a00001f 	beq	a000ace4 <rtems_rate_monotonic_period+0x128>  <== NOT EXECUTED
                                                                      
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
a000ac64:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a000ac68:	1affffe8 	bne	a000ac10 <rtems_rate_monotonic_period+0x54>   <== NOT EXECUTED
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
a000ac6c:	ebffff97 	bl	a000aad0 <_Rate_monotonic_Update_statistics>   <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000ac70:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
                                                                      
        _ISR_Enable( level );                                         
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
a000ac74:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000ac78:	e59f00dc 	ldr	r0, [pc, #220]	; a000ad5c <rtems_rate_monotonic_period+0x1a0><== NOT EXECUTED
a000ac7c:	e2861010 	add	r1, r6, #16                                   <== NOT EXECUTED
a000ac80:	e5863038 	str	r3, [r6, #56]	; 0x38                          <== NOT EXECUTED
        the_period->next_length = length;                             
a000ac84:	e586503c 	str	r5, [r6, #60]	; 0x3c                          <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000ac88:	e586501c 	str	r5, [r6, #28]                                 <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000ac8c:	eb000f8f 	bl	a000ead0 <_Watchdog_Insert>                    <== NOT EXECUTED
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_TIMEOUT;                                         
a000ac90:	e3a00006 	mov	r0, #6                                        <== NOT EXECUTED
a000ac94:	eaffffe6 	b	a000ac34 <rtems_rate_monotonic_period+0x78>     <== NOT EXECUTED
a000ac98:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
        _ISR_Enable( level );                                         
                                                                      
        /*                                                            
         *  Baseline statistics information for the beginning of a period.
         */                                                           
        _Rate_monotonic_Initiate_statistics( the_period );            
a000ac9c:	ebffff6b 	bl	a000aa50 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
a000aca0:	e3a03002 	mov	r3, #2                                        <== NOT EXECUTED
a000aca4:	e5863038 	str	r3, [r6, #56]	; 0x38                          <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a000aca8:	e59f30b0 	ldr	r3, [pc, #176]	; a000ad60 <rtems_rate_monotonic_period+0x1a4><== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000acac:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000acb0:	e59f00a4 	ldr	r0, [pc, #164]	; a000ad5c <rtems_rate_monotonic_period+0x1a0><== NOT EXECUTED
a000acb4:	e2861010 	add	r1, r6, #16                                   <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a000acb8:	e586302c 	str	r3, [r6, #44]	; 0x2c                          <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000acbc:	e5867018 	str	r7, [r6, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
a000acc0:	e5864030 	str	r4, [r6, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a000acc4:	e5867034 	str	r7, [r6, #52]	; 0x34                          <== NOT EXECUTED
          _Rate_monotonic_Timeout,                                    
          id,                                                         
          NULL                                                        
        );                                                            
                                                                      
        the_period->next_length = length;                             
a000acc8:	e586503c 	str	r5, [r6, #60]	; 0x3c                          <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000accc:	e586501c 	str	r5, [r6, #28]                                 <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000acd0:	eb000f7e 	bl	a000ead0 <_Watchdog_Insert>                    <== NOT EXECUTED
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
a000acd4:	e58d7000 	str	r7, [sp]                                      <== NOT EXECUTED
a000acd8:	eb000bc8 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a000acdc:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a000ace0:	eaffffc8 	b	a000ac08 <rtems_rate_monotonic_period+0x4c>     <== NOT EXECUTED
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
a000ace4:	ebffff79 	bl	a000aad0 <_Rate_monotonic_Update_statistics>   <== NOT EXECUTED
        /*                                                            
         *  This tells the _Rate_monotonic_Timeout that this task is  
         *  in the process of blocking on the period and that we      
         *  may be changing the length of the next period.            
         */                                                           
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
a000ace8:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000acec:	e5863038 	str	r3, [r6, #56]	; 0x38                          <== NOT EXECUTED
        the_period->next_length = length;                             
a000acf0:	e586503c 	str	r5, [r6, #60]	; 0x3c                          <== NOT EXECUTED
a000acf4:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
                                                                      
        _ISR_Enable( level );                                         
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
a000acf8:	e5973004 	ldr	r3, [r7, #4]                                  <== NOT EXECUTED
a000acfc:	e5962008 	ldr	r2, [r6, #8]                                  <== NOT EXECUTED
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a000ad00:	e3a01901 	mov	r1, #16384	; 0x4000                           <== NOT EXECUTED
a000ad04:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
        the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;         
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
a000ad08:	e5832020 	str	r2, [r3, #32]                                 <== NOT EXECUTED
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a000ad0c:	eb000dd4 	bl	a000e464 <_Thread_Set_state>                   <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000ad10:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000ad14:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000ad18:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
          local_state = the_period->state;                            
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
a000ad1c:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
          local_state = the_period->state;                            
a000ad20:	e5963038 	ldr	r3, [r6, #56]	; 0x38                          <== NOT EXECUTED
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
a000ad24:	e5861038 	str	r1, [r6, #56]	; 0x38                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000ad28:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
        /*                                                            
         *  If it did, then we want to unblock ourself and continue as
         *  if nothing happen.  The period was reset in the timeout routine.
         */                                                           
        if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )   
a000ad2c:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a000ad30:	0a000002 	beq	a000ad40 <rtems_rate_monotonic_period+0x184>  <== NOT EXECUTED
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
                                                                      
        _Thread_Enable_dispatch();                                    
a000ad34:	eb000bb1 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a000ad38:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000ad3c:	eaffffb1 	b	a000ac08 <rtems_rate_monotonic_period+0x4c>     <== NOT EXECUTED
        /*                                                            
         *  If it did, then we want to unblock ourself and continue as
         *  if nothing happen.  The period was reset in the timeout routine.
         */                                                           
        if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )   
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
a000ad40:	e5970004 	ldr	r0, [r7, #4]                                  <== NOT EXECUTED
a000ad44:	e3a01901 	mov	r1, #16384	; 0x4000                           <== NOT EXECUTED
a000ad48:	eb000ace 	bl	a000d888 <_Thread_Clear_state>                 <== NOT EXECUTED
a000ad4c:	eafffff8 	b	a000ad34 <rtems_rate_monotonic_period+0x178>    <== NOT EXECUTED
                                                                      

a000af7c <rtems_rate_monotonic_report_statistics>: } } void rtems_rate_monotonic_report_statistics( void ) { rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
a000af7c:	e59f1004 	ldr	r1, [pc, #4]	; a000af88 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED
a000af80:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000af84:	eaffff76 	b	a000ad64 <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
                                                                      

a000ad64 <rtems_rate_monotonic_report_statistics_with_plugin>: */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
a000ad64:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_id                               id;                          
  rtems_rate_monotonic_period_statistics the_stats;                   
  rtems_rate_monotonic_period_status     the_status;                  
  char                                   name[5];                     
                                                                      
  if ( !print )                                                       
a000ad68:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
 */                                                                   
void rtems_rate_monotonic_report_statistics_with_plugin(              
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a000ad6c:	e24dd078 	sub	sp, sp, #120	; 0x78                           <== NOT EXECUTED
a000ad70:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
  rtems_id                               id;                          
  rtems_rate_monotonic_period_statistics the_stats;                   
  rtems_rate_monotonic_period_status     the_status;                  
  char                                   name[5];                     
                                                                      
  if ( !print )                                                       
a000ad74:	0a000040 	beq	a000ae7c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
a000ad78:	e59f11d0 	ldr	r1, [pc, #464]	; a000af50 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec><== NOT EXECUTED
a000ad7c:	e12fff35 	blx	r5                                            <== NOT EXECUTED
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
a000ad80:	e59f11cc 	ldr	r1, [pc, #460]	; a000af54 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0><== NOT EXECUTED
a000ad84:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ad88:	e12fff35 	blx	r5                                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000ad8c:	e59f61c4 	ldr	r6, [pc, #452]	; a000af58 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f4><== NOT EXECUTED
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
    (*print)( context, "--- Wall times are in seconds ---\n" );       
a000ad90:	e59f11c4 	ldr	r1, [pc, #452]	; a000af5c <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== NOT EXECUTED
a000ad94:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ad98:	e12fff35 	blx	r5                                            <== NOT EXECUTED
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
a000ad9c:	e59f11bc 	ldr	r1, [pc, #444]	; a000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x1fc><== NOT EXECUTED
a000ada0:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ada4:	e12fff35 	blx	r5                                            <== NOT EXECUTED
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
a000ada8:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000adac:	e59f11b0 	ldr	r1, [pc, #432]	; a000af64 <rtems_rate_monotonic_report_statistics_with_plugin+0x200><== NOT EXECUTED
a000adb0:	e12fff35 	blx	r5                                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000adb4:	e5964008 	ldr	r4, [r6, #8]                                  <== NOT EXECUTED
a000adb8:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
a000adbc:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000adc0:	8a00002d 	bhi	a000ae7c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
a000adc4:	e28d7018 	add	r7, sp, #24                                   <== NOT EXECUTED
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
a000adc8:	e2870018 	add	r0, r7, #24                                   <== NOT EXECUTED
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
a000adcc:	e2871030 	add	r1, r7, #48	; 0x30                            <== NOT EXECUTED
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
      (*print)( context,                                              
a000add0:	e59fa190 	ldr	sl, [pc, #400]	; a000af68 <rtems_rate_monotonic_report_statistics_with_plugin+0x204><== NOT EXECUTED
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
a000add4:	e28d9070 	add	r9, sp, #112	; 0x70                           <== NOT EXECUTED
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
a000add8:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
a000addc:	e28db068 	add	fp, sp, #104	; 0x68                           <== NOT EXECUTED
    {                                                                 
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
a000ade0:	e58d1014 	str	r1, [sp, #20]                                 <== NOT EXECUTED
a000ade4:	ea000003 	b	a000adf8 <rtems_rate_monotonic_report_statistics_with_plugin+0x94><== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000ade8:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
a000adec:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000adf0:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000adf4:	3a000020 	bcc	a000ae7c <rtems_rate_monotonic_report_statistics_with_plugin+0x118><== NOT EXECUTED
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
a000adf8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000adfc:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a000ae00:	eb001708 	bl	a0010a28 <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
    if ( status != RTEMS_SUCCESSFUL )                                 
a000ae04:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ae08:	1afffff6 	bne	a000ade8 <rtems_rate_monotonic_report_statistics_with_plugin+0x84><== NOT EXECUTED
    #if defined(RTEMS_DEBUG)                                          
      status = rtems_rate_monotonic_get_status( id, &the_status );    
      if ( status != RTEMS_SUCCESSFUL )                               
        continue;                                                     
    #else                                                             
      (void) rtems_rate_monotonic_get_status( id, &the_status );      
a000ae0c:	e28d1050 	add	r1, sp, #80	; 0x50                            <== NOT EXECUTED
a000ae10:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000ae14:	eb001731 	bl	a0010ae0 <rtems_rate_monotonic_get_status>     <== NOT EXECUTED
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
a000ae18:	e1a02009 	mov	r2, r9                                        <== NOT EXECUTED
a000ae1c:	e3a01005 	mov	r1, #5                                        <== NOT EXECUTED
a000ae20:	e59d0050 	ldr	r0, [sp, #80]	; 0x50                          <== NOT EXECUTED
a000ae24:	eb0000b9 	bl	a000b110 <rtems_object_get_name>               <== NOT EXECUTED
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
a000ae28:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
a000ae2c:	e59f1138 	ldr	r1, [pc, #312]	; a000af6c <rtems_rate_monotonic_report_statistics_with_plugin+0x208><== NOT EXECUTED
a000ae30:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000ae34:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000ae38:	e59d301c 	ldr	r3, [sp, #28]                                 <== NOT EXECUTED
a000ae3c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ae40:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
a000ae44:	e1a03009 	mov	r3, r9                                        <== NOT EXECUTED
a000ae48:	e12fff35 	blx	r5                                            <== NOT EXECUTED
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
a000ae4c:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
a000ae50:	e59d0010 	ldr	r0, [sp, #16]                                 <== NOT EXECUTED
a000ae54:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
a000ae58:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      (*print)( context, "\n" );                                      
a000ae5c:	e59f110c 	ldr	r1, [pc, #268]	; a000af70 <rtems_rate_monotonic_report_statistics_with_plugin+0x20c><== NOT EXECUTED
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
a000ae60:	1a000007 	bne	a000ae84 <rtems_rate_monotonic_report_statistics_with_plugin+0x120><== NOT EXECUTED
      (*print)( context, "\n" );                                      
a000ae64:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000ae68:	e12fff35 	blx	r5                                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000ae6c:	e596300c 	ldr	r3, [r6, #12]                                 <== NOT EXECUTED
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
a000ae70:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Cycle through all possible ids and try to report on each one.  If it
   * is a period that is inactive, we just get an error back.  No big deal.
   */                                                                 
  for ( id=_Rate_monotonic_Information.minimum_id ;                   
a000ae74:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000ae78:	2affffde 	bcs	a000adf8 <rtems_rate_monotonic_report_statistics_with_plugin+0x94><== NOT EXECUTED
        the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
      );                                                              
    #endif                                                            
    }                                                                 
  }                                                                   
}                                                                     
a000ae7c:	e28dd078 	add	sp, sp, #120	; 0x78                           <== NOT EXECUTED
a000ae80:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
      struct timespec  cpu_average;                                   
      struct timespec *min_cpu = &the_stats.min_cpu_time;             
      struct timespec *max_cpu = &the_stats.max_cpu_time;             
      struct timespec *total_cpu = &the_stats.total_cpu_time;         
                                                                      
      _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
a000ae84:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a000ae88:	eb000e13 	bl	a000e6dc <_Timespec_Divide_by_integer>         <== NOT EXECUTED
      (*print)( context,                                              
a000ae8c:	e59d2024 	ldr	r2, [sp, #36]	; 0x24                          <== NOT EXECUTED
a000ae90:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
a000ae94:	e59d102c 	ldr	r1, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a000ae98:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000ae9c:	e0c3c29a 	smull	ip, r3, sl, r2                              <== NOT EXECUTED
a000aea0:	e1a02fc2 	asr	r2, r2, #31                                   <== NOT EXECUTED
a000aea4:	e0623343 	rsb	r3, r2, r3, asr #6                            <== NOT EXECUTED
a000aea8:	e59d2068 	ldr	r2, [sp, #104]	; 0x68                         <== NOT EXECUTED
a000aeac:	e0c0c19a 	smull	ip, r0, sl, r1                              <== NOT EXECUTED
a000aeb0:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a000aeb4:	e59d206c 	ldr	r2, [sp, #108]	; 0x6c                         <== NOT EXECUTED
a000aeb8:	e1a01fc1 	asr	r1, r1, #31                                   <== NOT EXECUTED
a000aebc:	e0611340 	rsb	r1, r1, r0, asr #6                            <== NOT EXECUTED
a000aec0:	e0c0c29a 	smull	ip, r0, sl, r2                              <== NOT EXECUTED
a000aec4:	e1a02fc2 	asr	r2, r2, #31                                   <== NOT EXECUTED
a000aec8:	e0622340 	rsb	r2, r2, r0, asr #6                            <== NOT EXECUTED
a000aecc:	e58d1004 	str	r1, [sp, #4]                                  <== NOT EXECUTED
a000aed0:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
a000aed4:	e59f1098 	ldr	r1, [pc, #152]	; a000af74 <rtems_rate_monotonic_report_statistics_with_plugin+0x210><== NOT EXECUTED
a000aed8:	e59d2020 	ldr	r2, [sp, #32]                                 <== NOT EXECUTED
a000aedc:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000aee0:	e12fff35 	blx	r5                                            <== NOT EXECUTED
      struct timespec  wall_average;                                  
      struct timespec *min_wall = &the_stats.min_wall_time;           
      struct timespec *max_wall = &the_stats.max_wall_time;           
      struct timespec *total_wall = &the_stats.total_wall_time;       
                                                                      
      _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
a000aee4:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
a000aee8:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
a000aeec:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a000aef0:	eb000df9 	bl	a000e6dc <_Timespec_Divide_by_integer>         <== NOT EXECUTED
      (*print)( context,                                              
a000aef4:	e59d2040 	ldr	r2, [sp, #64]	; 0x40                          <== NOT EXECUTED
a000aef8:	e59d303c 	ldr	r3, [sp, #60]	; 0x3c                          <== NOT EXECUTED
a000aefc:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000af00:	e59d2044 	ldr	r2, [sp, #68]	; 0x44                          <== NOT EXECUTED
a000af04:	e0c0139a 	smull	r1, r0, sl, r3                              <== NOT EXECUTED
a000af08:	e0c1c29a 	smull	ip, r1, sl, r2                              <== NOT EXECUTED
a000af0c:	e1a02fc2 	asr	r2, r2, #31                                   <== NOT EXECUTED
a000af10:	e0622341 	rsb	r2, r2, r1, asr #6                            <== NOT EXECUTED
a000af14:	e58d2004 	str	r2, [sp, #4]                                  <== NOT EXECUTED
a000af18:	e59d2068 	ldr	r2, [sp, #104]	; 0x68                         <== NOT EXECUTED
a000af1c:	e1a03fc3 	asr	r3, r3, #31                                   <== NOT EXECUTED
a000af20:	e0633340 	rsb	r3, r3, r0, asr #6                            <== NOT EXECUTED
a000af24:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a000af28:	e59d206c 	ldr	r2, [sp, #108]	; 0x6c                         <== NOT EXECUTED
a000af2c:	e59f1044 	ldr	r1, [pc, #68]	; a000af78 <rtems_rate_monotonic_report_statistics_with_plugin+0x214><== NOT EXECUTED
a000af30:	e0c0c29a 	smull	ip, r0, sl, r2                              <== NOT EXECUTED
a000af34:	e1a02fc2 	asr	r2, r2, #31                                   <== NOT EXECUTED
a000af38:	e0622340 	rsb	r2, r2, r0, asr #6                            <== NOT EXECUTED
a000af3c:	e58d200c 	str	r2, [sp, #12]                                 <== NOT EXECUTED
a000af40:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000af44:	e59d2038 	ldr	r2, [sp, #56]	; 0x38                          <== NOT EXECUTED
a000af48:	e12fff35 	blx	r5                                            <== NOT EXECUTED
a000af4c:	eaffffa5 	b	a000ade8 <rtems_rate_monotonic_report_statistics_with_plugin+0x84><== NOT EXECUTED
                                                                      

a000af8c <rtems_rate_monotonic_reset_all_statistics>: rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1;
a000af8c:	e59f3040 	ldr	r3, [pc, #64]	; a000afd4 <rtems_rate_monotonic_reset_all_statistics+0x48><== NOT EXECUTED
                                                                      
/*                                                                    
 *  rtems_rate_monotonic_reset_all_statistics                         
 */                                                                   
void rtems_rate_monotonic_reset_all_statistics( void )                
{                                                                     
a000af90:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000af94:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000af98:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000af9c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
a000afa0:	e59f5030 	ldr	r5, [pc, #48]	; a000afd8 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NOT EXECUTED
a000afa4:	e5954008 	ldr	r4, [r5, #8]                                  <== NOT EXECUTED
a000afa8:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
a000afac:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000afb0:	8a000005 	bhi	a000afcc <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
      (void) rtems_rate_monotonic_reset_statistics( id );             
a000afb4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000afb8:	eb000007 	bl	a000afdc <rtems_rate_monotonic_reset_statistics><== NOT EXECUTED
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
a000afbc:	e595300c 	ldr	r3, [r5, #12]                                 <== NOT EXECUTED
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
a000afc0:	e2844001 	add	r4, r4, #1                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * Cycle through all possible ids and try to reset each one.  If it
     * is a period that is inactive, we just get an error back.  No big deal.
     */                                                               
    for ( id=_Rate_monotonic_Information.minimum_id ;                 
a000afc4:	e1530004 	cmp	r3, r4                                        <== NOT EXECUTED
a000afc8:	2afffff9 	bcs	a000afb4 <rtems_rate_monotonic_reset_all_statistics+0x28><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Done so exit thread dispatching disabled critical section.      
   */                                                                 
  _Thread_Enable_dispatch();                                          
}                                                                     
a000afcc:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    }                                                                 
                                                                      
  /*                                                                  
   *  Done so exit thread dispatching disabled critical section.      
   */                                                                 
  _Thread_Enable_dispatch();                                          
a000afd0:	ea000b0a 	b	a000dc00 <_Thread_Enable_dispatch>              <== NOT EXECUTED
                                                                      

a000afdc <rtems_rate_monotonic_reset_statistics>: */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) {
a000afdc:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000afe0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000afe4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000afe8:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000afec:	e59f005c 	ldr	r0, [pc, #92]	; a000b050 <rtems_rate_monotonic_reset_statistics+0x74><== NOT EXECUTED
a000aff0:	eb0007af 	bl	a000ceb4 <_Objects_Get>                        <== NOT EXECUTED
  Objects_Locations              location;                            
  Rate_monotonic_Control        *the_period;                          
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a000aff4:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a000aff8:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000affc:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Objects_Locations              location;                            
  Rate_monotonic_Control        *the_period;                          
                                                                      
  the_period = _Rate_monotonic_Get( id, &location );                  
  switch ( location ) {                                               
a000b000:	1a000010 	bne	a000b048 <rtems_rate_monotonic_reset_statistics+0x6c><== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _Rate_monotonic_Reset_statistics( the_period );                 
a000b004:	e3e03102 	mvn	r3, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a000b008:	e5804054 	str	r4, [r0, #84]	; 0x54                          <== NOT EXECUTED
a000b00c:	e5804058 	str	r4, [r0, #88]	; 0x58                          <== NOT EXECUTED
a000b010:	e5804064 	str	r4, [r0, #100]	; 0x64                         <== NOT EXECUTED
a000b014:	e5804068 	str	r4, [r0, #104]	; 0x68                         <== NOT EXECUTED
a000b018:	e580406c 	str	r4, [r0, #108]	; 0x6c                         <== NOT EXECUTED
a000b01c:	e5804070 	str	r4, [r0, #112]	; 0x70                         <== NOT EXECUTED
a000b020:	e580407c 	str	r4, [r0, #124]	; 0x7c                         <== NOT EXECUTED
a000b024:	e5804080 	str	r4, [r0, #128]	; 0x80                         <== NOT EXECUTED
a000b028:	e5804084 	str	r4, [r0, #132]	; 0x84                         <== NOT EXECUTED
a000b02c:	e5804088 	str	r4, [r0, #136]	; 0x88                         <== NOT EXECUTED
a000b030:	e580305c 	str	r3, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a000b034:	e5803060 	str	r3, [r0, #96]	; 0x60                          <== NOT EXECUTED
a000b038:	e5803074 	str	r3, [r0, #116]	; 0x74                         <== NOT EXECUTED
a000b03c:	e5803078 	str	r3, [r0, #120]	; 0x78                         <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a000b040:	eb000aee 	bl	a000dc00 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000b044:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000b048:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000b04c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0018748 <rtems_region_create>: uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) {
a0018748:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_status_code  return_status;                                   
  Region_Control    *the_region;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a001874c:	e2509000 	subs	r9, r0, #0                                   <== NOT EXECUTED
  uintptr_t           length,                                         
  uintptr_t           page_size,                                      
  rtems_attribute     attribute_set,                                  
  rtems_id           *id                                              
)                                                                     
{                                                                     
a0018750:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0018754:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0018758:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
a001875c:	e1a06003 	mov	r6, r3                                        <== NOT EXECUTED
a0018760:	e59db02c 	ldr	fp, [sp, #44]	; 0x2c                          <== NOT EXECUTED
  rtems_status_code  return_status;                                   
  Region_Control    *the_region;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a0018764:	03a05003 	moveq	r5, #3                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  rtems_status_code  return_status;                                   
  Region_Control    *the_region;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0018768:	0a00001a 	beq	a00187d8 <rtems_region_create+0x90>           <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
a001876c:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0018770:	0a000035 	beq	a001884c <rtems_region_create+0x104>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
a0018774:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
a0018778:	0a000033 	beq	a001884c <rtems_region_create+0x104>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                      /* to prevent deletion */
a001877c:	e59f80d0 	ldr	r8, [pc, #208]	; a0018854 <rtems_region_create+0x10c><== NOT EXECUTED
 *  This function allocates a region control block from               
 *  the inactive chain of free region control blocks.                 
 */                                                                   
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )         
{                                                                     
  return (Region_Control *) _Objects_Allocate( &_Region_Information );
a0018780:	e59fa0d0 	ldr	sl, [pc, #208]	; a0018858 <rtems_region_create+0x110><== NOT EXECUTED
a0018784:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a0018788:	eb0009ac 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a001878c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0018790:	eb000fe4 	bl	a001c728 <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
    the_region = _Region_Allocate();                                  
                                                                      
    if ( !the_region )                                                
a0018794:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
      return_status = RTEMS_TOO_MANY;                                 
a0018798:	03a05005 	moveq	r5, #5                                      <== NOT EXECUTED
                                                                      
  _RTEMS_Lock_allocator();                      /* to prevent deletion */
                                                                      
    the_region = _Region_Allocate();                                  
                                                                      
    if ( !the_region )                                                
a001879c:	0a00000b 	beq	a00187d0 <rtems_region_create+0x88>           <== NOT EXECUTED
      return_status = RTEMS_TOO_MANY;                                 
                                                                      
    else {                                                            
                                                                      
      the_region->maximum_segment_size = _Heap_Initialize(            
a00187a0:	e2840068 	add	r0, r4, #104	; 0x68                           <== NOT EXECUTED
a00187a4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00187a8:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a00187ac:	e1a03006 	mov	r3, r6                                        <== NOT EXECUTED
a00187b0:	eb000eb7 	bl	a001c294 <_Heap_Initialize>                    <== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size      
      );                                                              
                                                                      
      if ( !the_region->maximum_segment_size ) {                      
a00187b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    if ( !the_region )                                                
      return_status = RTEMS_TOO_MANY;                                 
                                                                      
    else {                                                            
                                                                      
      the_region->maximum_segment_size = _Heap_Initialize(            
a00187b8:	e584005c 	str	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size      
      );                                                              
                                                                      
      if ( !the_region->maximum_segment_size ) {                      
a00187bc:	1a000008 	bne	a00187e4 <rtems_region_create+0x9c>           <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Region_Free (                              
  Region_Control *the_region                                          
)                                                                     
{                                                                     
  _Objects_Free( &_Region_Information, &the_region->Object );         
a00187c0:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a00187c4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00187c8:	eb0010b0 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
        _Region_Free( the_region );                                   
        return_status = RTEMS_INVALID_SIZE;                           
a00187cc:	e3a05008 	mov	r5, #8                                        <== NOT EXECUTED
        *id = the_region->Object.id;                                  
        return_status = RTEMS_SUCCESSFUL;                             
      }                                                               
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a00187d0:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a00187d4:	eb0009b5 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a00187d8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a00187dc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00187e0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
        the_region->length                = length;                   
        the_region->page_size             = page_size;                
        the_region->attribute_set         = attribute_set;            
        the_region->number_of_used_blocks = 0;                        
                                                                      
        _Thread_queue_Initialize(                                     
a00187e4:	e59d3028 	ldr	r3, [sp, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
        the_region->starting_address      = starting_address;         
        the_region->length                = length;                   
        the_region->page_size             = page_size;                
        the_region->attribute_set         = attribute_set;            
        the_region->number_of_used_blocks = 0;                        
a00187e8:	e3a0c000 	mov	ip, #0                                        <== NOT EXECUTED
        return_status = RTEMS_INVALID_SIZE;                           
      }                                                               
                                                                      
      else {                                                          
                                                                      
        the_region->starting_address      = starting_address;         
a00187ec:	e5845050 	str	r5, [r4, #80]	; 0x50                          <== NOT EXECUTED
        the_region->length                = length;                   
        the_region->page_size             = page_size;                
        the_region->attribute_set         = attribute_set;            
        the_region->number_of_used_blocks = 0;                        
                                                                      
        _Thread_queue_Initialize(                                     
a00187f0:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
      else {                                                          
                                                                      
        the_region->starting_address      = starting_address;         
        the_region->length                = length;                   
        the_region->page_size             = page_size;                
        the_region->attribute_set         = attribute_set;            
a00187f4:	e5843060 	str	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
        the_region->number_of_used_blocks = 0;                        
a00187f8:	e584c064 	str	ip, [r4, #100]	; 0x64                         <== NOT EXECUTED
      }                                                               
                                                                      
      else {                                                          
                                                                      
        the_region->starting_address      = starting_address;         
        the_region->length                = length;                   
a00187fc:	e5847054 	str	r7, [r4, #84]	; 0x54                          <== NOT EXECUTED
        the_region->page_size             = page_size;                
a0018800:	e5846058 	str	r6, [r4, #88]	; 0x58                          <== NOT EXECUTED
        the_region->attribute_set         = attribute_set;            
        the_region->number_of_used_blocks = 0;                        
                                                                      
        _Thread_queue_Initialize(                                     
a0018804:	e2840010 	add	r0, r4, #16                                   <== NOT EXECUTED
a0018808:	03a01000 	moveq	r1, #0                                      <== NOT EXECUTED
a001880c:	13a01001 	movne	r1, #1                                      <== NOT EXECUTED
a0018810:	e3a02040 	mov	r2, #64	; 0x40                                <== NOT EXECUTED
a0018814:	e3a03006 	mov	r3, #6                                        <== NOT EXECUTED
a0018818:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a001881c:	eb001622 	bl	a001e0ac <_Thread_queue_Initialize>            <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a0018820:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0018824:	e59a201c 	ldr	r2, [sl, #28]                                 <== NOT EXECUTED
          &the_region->Object,                                        
          (Objects_Name) name                                         
        );                                                            
                                                                      
        *id = the_region->Object.id;                                  
        return_status = RTEMS_SUCCESSFUL;                             
a0018828:	e59dc000 	ldr	ip, [sp]                                      <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a001882c:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a0018830:	e7824721 	str	r4, [r2, r1, lsr #14]                         <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018834:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a0018838:	e584900c 	str	r9, [r4, #12]                                 <== NOT EXECUTED
          &_Region_Information,                                       
          &the_region->Object,                                        
          (Objects_Name) name                                         
        );                                                            
                                                                      
        *id = the_region->Object.id;                                  
a001883c:	e58b3000 	str	r3, [fp]                                      <== NOT EXECUTED
        return_status = RTEMS_SUCCESSFUL;                             
a0018840:	e1a0500c 	mov	r5, ip                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018844:	eb000999 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
a0018848:	eaffffe2 	b	a00187d8 <rtems_region_create+0x90>             <== NOT EXECUTED
                                                                      
  if ( !starting_address )                                            
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
a001884c:	e3a05009 	mov	r5, #9                                        <== NOT EXECUTED
a0018850:	eaffffe0 	b	a00187d8 <rtems_region_create+0x90>             <== NOT EXECUTED
                                                                      

a001885c <rtems_region_delete>: */ rtems_status_code rtems_region_delete( rtems_id id ) {
a001885c:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018860:	e59f4070 	ldr	r4, [pc, #112]	; a00188d8 <rtems_region_delete+0x7c><== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_region_delete(                                
  rtems_id id                                                         
)                                                                     
{                                                                     
a0018864:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0018868:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a001886c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018870:	eb000972 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Region_Control *)                                           
    _Objects_Get_no_protection( &_Region_Information, id, location ); 
a0018874:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0018878:	e59f005c 	ldr	r0, [pc, #92]	; a00188dc <rtems_region_delete+0x80><== NOT EXECUTED
a001887c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0018880:	eb0010db 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018884:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0018888:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a001888c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a0018890:	13a06004 	movne	r6, #4                                      <== NOT EXECUTED
  Region_Control     *the_region;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018894:	1a000003 	bne	a00188a8 <rtems_region_delete+0x4c>           <== NOT EXECUTED
                                                                      
      case OBJECTS_LOCAL:                                             
        _Region_Debug_Walk( the_region, 5 );                          
        if ( the_region->number_of_used_blocks != 0 )                 
a0018898:	e5906064 	ldr	r6, [r0, #100]	; 0x64                         <== NOT EXECUTED
a001889c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
          return_status = RTEMS_RESOURCE_IN_USE;                      
a00188a0:	13a0600c 	movne	r6, #12                                     <== NOT EXECUTED
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
        _Region_Debug_Walk( the_region, 5 );                          
        if ( the_region->number_of_used_blocks != 0 )                 
a00188a4:	0a000004 	beq	a00188bc <rtems_region_delete+0x60>           <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a00188a8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a00188ac:	eb00097f 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a00188b0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00188b4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00188b8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
      case OBJECTS_LOCAL:                                             
        _Region_Debug_Walk( the_region, 5 );                          
        if ( the_region->number_of_used_blocks != 0 )                 
          return_status = RTEMS_RESOURCE_IN_USE;                      
        else {                                                        
          _Objects_Close( &_Region_Information, &the_region->Object );
a00188bc:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a00188c0:	e59f0014 	ldr	r0, [pc, #20]	; a00188dc <rtems_region_delete+0x80><== NOT EXECUTED
a00188c4:	eb000fbc 	bl	a001c7bc <_Objects_Close>                      <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Region_Free (                              
  Region_Control *the_region                                          
)                                                                     
{                                                                     
  _Objects_Free( &_Region_Information, &the_region->Object );         
a00188c8:	e59f000c 	ldr	r0, [pc, #12]	; a00188dc <rtems_region_delete+0x80><== NOT EXECUTED
a00188cc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00188d0:	eb00106e 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
a00188d4:	eafffff3 	b	a00188a8 <rtems_region_delete+0x4c>             <== NOT EXECUTED
                                                                      

a00188e0 <rtems_region_extend>: rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) {
a00188e0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  bool                extend_ok;                                      
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
                                                                      
  if ( !starting_address )                                            
a00188e4:	e2518000 	subs	r8, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_region_extend(                                
  rtems_id   id,                                                      
  void      *starting_address,                                        
  uintptr_t  length                                                   
)                                                                     
{                                                                     
a00188e8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a00188ec:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a00188f0:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
                                                                      
  if ( !starting_address )                                            
    return RTEMS_INVALID_ADDRESS;                                     
a00188f4:	03a05009 	moveq	r5, #9                                      <== NOT EXECUTED
  bool                extend_ok;                                      
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
                                                                      
  if ( !starting_address )                                            
a00188f8:	0a00000d 	beq	a0018934 <rtems_region_extend+0x54>           <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                      /* to prevent deletion */
a00188fc:	e59f407c 	ldr	r4, [pc, #124]	; a0018980 <rtems_region_extend+0xa0><== NOT EXECUTED
a0018900:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018904:	eb00094d 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Region_Control *)                                           
    _Objects_Get_no_protection( &_Region_Information, id, location ); 
a0018908:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a001890c:	e59f0070 	ldr	r0, [pc, #112]	; a0018984 <rtems_region_extend+0xa4><== NOT EXECUTED
a0018910:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0018914:	eb0010b6 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018918:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a001891c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0018920:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a0018924:	13a05004 	movne	r5, #4                                      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                      /* to prevent deletion */
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018928:	0a000004 	beq	a0018940 <rtems_region_extend+0x60>           <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a001892c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018930:	eb00095e 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a0018934:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0018938:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a001893c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
                                                                      
        extend_ok = _Heap_Extend(                                     
a0018940:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018944:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0018948:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a001894c:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
a0018950:	eb000c8b 	bl	a001bb84 <_Heap_Extend>                        <== NOT EXECUTED
          starting_address,                                           
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        if ( extend_ok ) {                                            
a0018954:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
          the_region->length                += amount_extended;       
          the_region->maximum_segment_size  += amount_extended;       
          return_status = RTEMS_SUCCESSFUL;                           
        } else {                                                      
          return_status = RTEMS_INVALID_ADDRESS;                      
a0018958:	03a05009 	moveq	r5, #9                                      <== NOT EXECUTED
          starting_address,                                           
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        if ( extend_ok ) {                                            
a001895c:	0afffff2 	beq	a001892c <rtems_region_extend+0x4c>           <== NOT EXECUTED
          the_region->length                += amount_extended;       
a0018960:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0018964:	e5962054 	ldr	r2, [r6, #84]	; 0x54                          <== NOT EXECUTED
          the_region->maximum_segment_size  += amount_extended;       
a0018968:	e596105c 	ldr	r1, [r6, #92]	; 0x5c                          <== NOT EXECUTED
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        if ( extend_ok ) {                                            
          the_region->length                += amount_extended;       
a001896c:	e0822003 	add	r2, r2, r3                                    <== NOT EXECUTED
          the_region->maximum_segment_size  += amount_extended;       
a0018970:	e0813003 	add	r3, r1, r3                                    <== NOT EXECUTED
          length,                                                     
          &amount_extended                                            
        );                                                            
                                                                      
        if ( extend_ok ) {                                            
          the_region->length                += amount_extended;       
a0018974:	e5862054 	str	r2, [r6, #84]	; 0x54                          <== NOT EXECUTED
          the_region->maximum_segment_size  += amount_extended;       
a0018978:	e586305c 	str	r3, [r6, #92]	; 0x5c                          <== NOT EXECUTED
a001897c:	eaffffea 	b	a001892c <rtems_region_extend+0x4c>             <== NOT EXECUTED
                                                                      

a0018988 <rtems_region_get_free_information>: rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) {
a0018988:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
a001898c:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_region_get_free_information(                  
  rtems_id                id,                                         
  Heap_Information_block *the_info                                    
)                                                                     
{                                                                     
a0018990:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0018994:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0018998:	03a06009 	moveq	r6, #9                                      <== NOT EXECUTED
{                                                                     
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
a001899c:	0a00000c 	beq	a00189d4 <rtems_region_get_free_information+0x4c><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a00189a0:	e59f4054 	ldr	r4, [pc, #84]	; a00189fc <rtems_region_get_free_information+0x74><== NOT EXECUTED
a00189a4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a00189a8:	eb000924 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a00189ac:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a00189b0:	e59f0048 	ldr	r0, [pc, #72]	; a0018a00 <rtems_region_get_free_information+0x78><== NOT EXECUTED
a00189b4:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a00189b8:	eb00108d 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a00189bc:	e59d6000 	ldr	r6, [sp]                                      <== NOT EXECUTED
a00189c0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a00189c4:	13a06004 	movne	r6, #4                                      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a00189c8:	0a000004 	beq	a00189e0 <rtems_region_get_free_information+0x58><== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a00189cc:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a00189d0:	eb000936 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a00189d4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00189d8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00189dc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
                                                                      
        the_info->Used.number   = 0;                                  
a00189e0:	e585600c 	str	r6, [r5, #12]                                 <== NOT EXECUTED
        the_info->Used.total    = 0;                                  
a00189e4:	e5856014 	str	r6, [r5, #20]                                 <== NOT EXECUTED
        the_info->Used.largest  = 0;                                  
a00189e8:	e5856010 	str	r6, [r5, #16]                                 <== NOT EXECUTED
                                                                      
        _Heap_Get_free_information( &the_region->Memory, &the_info->Free );
a00189ec:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a00189f0:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a00189f4:	eb000d82 	bl	a001c004 <_Heap_Get_free_information>          <== NOT EXECUTED
                                                                      
        return_status = RTEMS_SUCCESSFUL;                             
        break;                                                        
a00189f8:	eafffff3 	b	a00189cc <rtems_region_get_free_information+0x44><== NOT EXECUTED
                                                                      

a0018a04 <rtems_region_get_information>: rtems_status_code rtems_region_get_information( rtems_id id, Heap_Information_block *the_info ) {
a0018a04:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
a0018a08:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_region_get_information(                       
  rtems_id                id,                                         
  Heap_Information_block *the_info                                    
)                                                                     
{                                                                     
a0018a0c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0018a10:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0018a14:	03a06009 	moveq	r6, #9                                      <== NOT EXECUTED
{                                                                     
  Objects_Locations        location;                                  
  rtems_status_code        return_status;                             
  register Region_Control *the_region;                                
                                                                      
  if ( !the_info )                                                    
a0018a18:	0a00000c 	beq	a0018a50 <rtems_region_get_information+0x4c>  <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018a1c:	e59f4048 	ldr	r4, [pc, #72]	; a0018a6c <rtems_region_get_information+0x68><== NOT EXECUTED
a0018a20:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018a24:	eb000905 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a0018a28:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0018a2c:	e59f003c 	ldr	r0, [pc, #60]	; a0018a70 <rtems_region_get_information+0x6c><== NOT EXECUTED
a0018a30:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0018a34:	eb00106e 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018a38:	e59d6000 	ldr	r6, [sp]                                      <== NOT EXECUTED
a0018a3c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a0018a40:	13a06004 	movne	r6, #4                                      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018a44:	0a000004 	beq	a0018a5c <rtems_region_get_information+0x58>  <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018a48:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018a4c:	eb000917 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a0018a50:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0018a54:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0018a58:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
        _Heap_Get_information( &the_region->Memory, the_info );       
a0018a5c:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018a60:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0018a64:	eb000d80 	bl	a001c06c <_Heap_Get_information>               <== NOT EXECUTED
        return_status = RTEMS_SUCCESSFUL;                             
        break;                                                        
a0018a68:	eafffff6 	b	a0018a48 <rtems_region_get_information+0x44>    <== NOT EXECUTED
                                                                      

a0018a74 <rtems_region_get_segment>: uintptr_t size, rtems_option option_set, rtems_interval timeout, void **segment ) {
a0018a74:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0018a78:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0018a7c:	e59d402c 	ldr	r4, [sp, #44]	; 0x2c                          <== NOT EXECUTED
a0018a80:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0018a84:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
  void               *the_segment;                                    
                                                                      
  if ( !segment )                                                     
a0018a88:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
  uintptr_t          size,                                            
  rtems_option       option_set,                                      
  rtems_interval     timeout,                                         
  void              **segment                                         
)                                                                     
{                                                                     
a0018a8c:	e1a0a002 	mov	sl, r2                                        <== NOT EXECUTED
a0018a90:	e1a09003 	mov	r9, r3                                        <== NOT EXECUTED
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
  void               *the_segment;                                    
                                                                      
  if ( !segment )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
a0018a94:	03a0b009 	moveq	fp, #9                                      <== NOT EXECUTED
  Objects_Locations   location;                                       
  rtems_status_code   return_status;                                  
  Region_Control     *the_region;                                     
  void               *the_segment;                                    
                                                                      
  if ( !segment )                                                     
a0018a98:	0a000004 	beq	a0018ab0 <rtems_region_get_segment+0x3c>      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  *segment = NULL;                                                    
                                                                      
  if ( size == 0 )                                                    
a0018a9c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
  void               *the_segment;                                    
                                                                      
  if ( !segment )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  *segment = NULL;                                                    
a0018aa0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0018aa4:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
                                                                      
  if ( size == 0 )                                                    
    return RTEMS_INVALID_SIZE;                                        
a0018aa8:	03a0b008 	moveq	fp, #8                                      <== NOT EXECUTED
  if ( !segment )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  *segment = NULL;                                                    
                                                                      
  if ( size == 0 )                                                    
a0018aac:	1a000002 	bne	a0018abc <rtems_region_get_segment+0x48>      <== NOT EXECUTED
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return return_status;                                               
}                                                                     
a0018ab0:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a0018ab4:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0018ab8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  *segment = NULL;                                                    
                                                                      
  if ( size == 0 )                                                    
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018abc:	e59f80e0 	ldr	r8, [pc, #224]	; a0018ba4 <rtems_region_get_segment+0x130><== NOT EXECUTED
a0018ac0:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a0018ac4:	eb0008dd 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
                                                                      
    executing  = _Thread_Executing;                                   
a0018ac8:	e59f30d8 	ldr	r3, [pc, #216]	; a0018ba8 <rtems_region_get_segment+0x134><== NOT EXECUTED
a0018acc:	e59f00d8 	ldr	r0, [pc, #216]	; a0018bac <rtems_region_get_segment+0x138><== NOT EXECUTED
a0018ad0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0018ad4:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0018ad8:	e28d2004 	add	r2, sp, #4                                    <== NOT EXECUTED
a0018adc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0018ae0:	eb001043 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018ae4:	e59db004 	ldr	fp, [sp, #4]                                  <== NOT EXECUTED
a0018ae8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0018aec:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a0018af0:	13a0b004 	movne	fp, #4                                      <== NOT EXECUTED
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
    executing  = _Thread_Executing;                                   
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018af4:	1a000003 	bne	a0018b08 <rtems_region_get_segment+0x94>      <== NOT EXECUTED
                                                                      
      case OBJECTS_LOCAL:                                             
        if ( size > the_region->maximum_segment_size )                
a0018af8:	e590305c 	ldr	r3, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a0018afc:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
          return_status = RTEMS_INVALID_SIZE;                         
a0018b00:	83a0b008 	movhi	fp, #8                                      <== NOT EXECUTED
    executing  = _Thread_Executing;                                   
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
        if ( size > the_region->maximum_segment_size )                
a0018b04:	9a000002 	bls	a0018b14 <rtems_region_get_segment+0xa0>      <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018b08:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a0018b0c:	eb0008e7 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
a0018b10:	eaffffe6 	b	a0018ab0 <rtems_region_get_segment+0x3c>        <== NOT EXECUTED
 * @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
 * boundary equals zero.                                              
 */                                                                   
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{                                                                     
  return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );    
a0018b14:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018b18:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0018b1c:	e1a0200b 	mov	r2, fp                                        <== NOT EXECUTED
a0018b20:	e1a0300b 	mov	r3, fp                                        <== NOT EXECUTED
a0018b24:	eb000b7e 	bl	a001b924 <_Heap_Allocate_aligned_with_boundary><== NOT EXECUTED
                                                                      
          the_segment = _Region_Allocate_segment( the_region, size ); 
                                                                      
          _Region_Debug_Walk( the_region, 2 );                        
                                                                      
          if ( the_segment ) {                                        
a0018b28:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0018b2c:	0a000004 	beq	a0018b44 <rtems_region_get_segment+0xd0>      <== NOT EXECUTED
            the_region->number_of_used_blocks += 1;                   
a0018b30:	e5973064 	ldr	r3, [r7, #100]	; 0x64                         <== NOT EXECUTED
a0018b34:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0018b38:	e5873064 	str	r3, [r7, #100]	; 0x64                         <== NOT EXECUTED
            *segment = the_segment;                                   
a0018b3c:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
a0018b40:	eafffff0 	b	a0018b08 <rtems_region_get_segment+0x94>        <== NOT EXECUTED
            return_status = RTEMS_SUCCESSFUL;                         
          } else if ( _Options_Is_no_wait( option_set ) ) {           
a0018b44:	e31a0001 	tst	sl, #1                                        <== NOT EXECUTED
            return_status = RTEMS_UNSATISFIED;                        
a0018b48:	13a0b00d 	movne	fp, #13                                     <== NOT EXECUTED
                                                                      
          if ( the_segment ) {                                        
            the_region->number_of_used_blocks += 1;                   
            *segment = the_segment;                                   
            return_status = RTEMS_SUCCESSFUL;                         
          } else if ( _Options_Is_no_wait( option_set ) ) {           
a0018b4c:	1affffed 	bne	a0018b08 <rtems_region_get_segment+0x94>      <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a0018b50:	e59f3058 	ldr	r3, [pc, #88]	; a0018bb0 <rtems_region_get_segment+0x13c><== NOT EXECUTED
a0018b54:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a0018b58:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0018b5c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
             *  Switch from using the memory allocation mutex to using a
             *  dispatching disabled critical section.  We have to do this
             *  because this thread is going to block.                
             */                                                       
            _Thread_Disable_dispatch();                               
            _RTEMS_Unlock_allocator();                                
a0018b60:	e5980000 	ldr	r0, [r8]                                      <== NOT EXECUTED
a0018b64:	eb0008d1 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
                                                                      
            executing->Wait.queue           = &the_region->Wait_queue;
a0018b68:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0018b6c:	e2870010 	add	r0, r7, #16                                   <== NOT EXECUTED
            executing->Wait.count           = size;                   
            executing->Wait.return_argument = segment;                
                                                                      
            _Thread_queue_Enter_critical_section( &the_region->Wait_queue );
                                                                      
            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
a0018b70:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
             *  because this thread is going to block.                
             */                                                       
            _Thread_Disable_dispatch();                               
            _RTEMS_Unlock_allocator();                                
                                                                      
            executing->Wait.queue           = &the_region->Wait_queue;
a0018b74:	e5830044 	str	r0, [r3, #68]	; 0x44                          <== NOT EXECUTED
            executing->Wait.id              = id;                     
a0018b78:	e5836020 	str	r6, [r3, #32]                                 <== NOT EXECUTED
            executing->Wait.count           = size;                   
a0018b7c:	e5835024 	str	r5, [r3, #36]	; 0x24                          <== NOT EXECUTED
            executing->Wait.return_argument = segment;                
a0018b80:	e5834028 	str	r4, [r3, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0018b84:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0018b88:	e5873040 	str	r3, [r7, #64]	; 0x40                          <== NOT EXECUTED
                                                                      
            _Thread_queue_Enter_critical_section( &the_region->Wait_queue );
                                                                      
            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
a0018b8c:	e59f2020 	ldr	r2, [pc, #32]	; a0018bb4 <rtems_region_get_segment+0x140><== NOT EXECUTED
a0018b90:	eb001497 	bl	a001ddf4 <_Thread_queue_Enqueue_with_handler>  <== NOT EXECUTED
                                                                      
            _Thread_Enable_dispatch();                                
a0018b94:	eb001379 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
                                                                      
            return (rtems_status_code) executing->Wait.return_code;   
a0018b98:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0018b9c:	e593b034 	ldr	fp, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0018ba0:	eaffffc2 	b	a0018ab0 <rtems_region_get_segment+0x3c>        <== NOT EXECUTED
                                                                      

a0018bb8 <rtems_region_get_segment_size>: rtems_status_code rtems_region_get_segment_size( rtems_id id, void *segment, uintptr_t *size ) {
a0018bb8:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status = RTEMS_SUCCESSFUL;          
  register Region_Control *the_region;                                
                                                                      
  if ( !segment )                                                     
a0018bbc:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(                      
  rtems_id   id,                                                      
  void      *segment,                                                 
  uintptr_t *size                                                     
)                                                                     
{                                                                     
a0018bc0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0018bc4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0018bc8:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  Objects_Locations        location;                                  
  rtems_status_code        return_status = RTEMS_SUCCESSFUL;          
  register Region_Control *the_region;                                
                                                                      
  if ( !segment )                                                     
a0018bcc:	0a00001b 	beq	a0018c40 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !size )                                                        
a0018bd0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0018bd4:	0a000019 	beq	a0018c40 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018bd8:	e59f4068 	ldr	r4, [pc, #104]	; a0018c48 <rtems_region_get_segment_size+0x90><== NOT EXECUTED
a0018bdc:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018be0:	eb000896 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a0018be4:	e59f0060 	ldr	r0, [pc, #96]	; a0018c4c <rtems_region_get_segment_size+0x94><== NOT EXECUTED
a0018be8:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0018bec:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0018bf0:	eb000fff 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018bf4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0018bf8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0018bfc:	0a000007 	beq	a0018c20 <rtems_region_get_segment_size+0x68> <== NOT EXECUTED
  void      *segment,                                                 
  uintptr_t *size                                                     
)                                                                     
{                                                                     
  Objects_Locations        location;                                  
  rtems_status_code        return_status = RTEMS_SUCCESSFUL;          
a0018c00:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a0018c04:	03a05004 	moveq	r5, #4                                      <== NOT EXECUTED
a0018c08:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
      case OBJECTS_ERROR:                                             
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018c0c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018c10:	eb0008a6 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a0018c14:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0018c18:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0018c1c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
                                                                      
      case OBJECTS_LOCAL:                                             
        if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
a0018c20:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0018c24:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018c28:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0018c2c:	eb000e83 	bl	a001c640 <_Heap_Size_of_alloc_area>            <== NOT EXECUTED
  void      *segment,                                                 
  uintptr_t *size                                                     
)                                                                     
{                                                                     
  Objects_Locations        location;                                  
  rtems_status_code        return_status = RTEMS_SUCCESSFUL;          
a0018c30:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0018c34:	03a05009 	moveq	r5, #9                                      <== NOT EXECUTED
a0018c38:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
a0018c3c:	eafffff2 	b	a0018c0c <rtems_region_get_segment_size+0x54>   <== NOT EXECUTED
                                                                      
  if ( !segment )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !size )                                                        
    return RTEMS_INVALID_ADDRESS;                                     
a0018c40:	e3a05009 	mov	r5, #9                                        <== NOT EXECUTED
a0018c44:	eafffff2 	b	a0018c14 <rtems_region_get_segment_size+0x5c>   <== NOT EXECUTED
                                                                      

a0018c50 <rtems_region_ident>: rtems_status_code rtems_region_ident( rtems_name name, rtems_id *id ) {
a0018c50:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a0018c54:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a0018c58:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a0018c5c:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0018c60:	e59f0010 	ldr	r0, [pc, #16]	; a0018c78 <rtems_region_ident+0x28><== NOT EXECUTED
a0018c64:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0018c68:	eb001046 	bl	a001cd88 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_LOCAL_NODE,                                        
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a0018c6c:	e59f3008 	ldr	r3, [pc, #8]	; a0018c7c <rtems_region_ident+0x2c><== NOT EXECUTED
}                                                                     
a0018c70:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a0018c74:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0018c80 <rtems_region_resize_segment>: rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) {
a0018c80:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  uintptr_t                osize;                                     
  rtems_status_code        return_status;                             
  Heap_Resize_status       status;                                    
  register Region_Control *the_region;                                
                                                                      
  if ( !old_size )                                                    
a0018c84:	e2535000 	subs	r5, r3, #0                                   <== NOT EXECUTED
  rtems_id    id,                                                     
  void       *segment,                                                
  uintptr_t   size,                                                   
  uintptr_t  *old_size                                                
)                                                                     
{                                                                     
a0018c88:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0018c8c:	e24dd010 	sub	sp, sp, #16                                   <== NOT EXECUTED
a0018c90:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
a0018c94:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  rtems_status_code        return_status;                             
  Heap_Resize_status       status;                                    
  register Region_Control *the_region;                                
                                                                      
  if ( !old_size )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0018c98:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  uintptr_t                osize;                                     
  rtems_status_code        return_status;                             
  Heap_Resize_status       status;                                    
  register Region_Control *the_region;                                
                                                                      
  if ( !old_size )                                                    
a0018c9c:	0a00000d 	beq	a0018cd8 <rtems_region_resize_segment+0x58>   <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018ca0:	e59f408c 	ldr	r4, [pc, #140]	; a0018d34 <rtems_region_resize_segment+0xb4><== NOT EXECUTED
a0018ca4:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018ca8:	eb000864 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a0018cac:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0018cb0:	e59f0080 	ldr	r0, [pc, #128]	; a0018d38 <rtems_region_resize_segment+0xb8><== NOT EXECUTED
a0018cb4:	e28d2008 	add	r2, sp, #8                                    <== NOT EXECUTED
a0018cb8:	eb000fcd 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018cbc:	e59d3008 	ldr	r3, [sp, #8]                                  <== NOT EXECUTED
a0018cc0:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0018cc4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0018cc8:	0a000004 	beq	a0018ce0 <rtems_region_resize_segment+0x60>   <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018ccc:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018cd0:	eb000876 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
a0018cd4:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
}                                                                     
a0018cd8:	e28dd010 	add	sp, sp, #16                                   <== NOT EXECUTED
a0018cdc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
      case OBJECTS_LOCAL:                                             
                                                                      
        _Region_Debug_Walk( the_region, 7 );                          
                                                                      
        status = _Heap_Resize_block(                                  
a0018ce0:	e28d300c 	add	r3, sp, #12                                   <== NOT EXECUTED
a0018ce4:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0018ce8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0018cec:	e28d3004 	add	r3, sp, #4                                    <== NOT EXECUTED
a0018cf0:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018cf4:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0018cf8:	eb000e00 	bl	a001c500 <_Heap_Resize_block>                  <== NOT EXECUTED
          segment,                                                    
          (uint32_t) size,                                            
          &osize,                                                     
          &avail_size                                                 
        );                                                            
        *old_size = (uint32_t) osize;                                 
a0018cfc:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
                                                                      
        _Region_Debug_Walk( the_region, 8 );                          
                                                                      
        if ( status == HEAP_RESIZE_SUCCESSFUL )                       
a0018d00:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
          segment,                                                    
          (uint32_t) size,                                            
          &osize,                                                     
          &avail_size                                                 
        );                                                            
        *old_size = (uint32_t) osize;                                 
a0018d04:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
        _Region_Debug_Walk( the_region, 8 );                          
                                                                      
        if ( status == HEAP_RESIZE_SUCCESSFUL )                       
a0018d08:	1a000003 	bne	a0018d1c <rtems_region_resize_segment+0x9c>   <== NOT EXECUTED
          _Region_Process_queue( the_region );    /* unlocks allocator */
a0018d0c:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0018d10:	eb001f2c 	bl	a00209c8 <_Region_Process_queue>               <== NOT EXECUTED
        else                                                          
          _RTEMS_Unlock_allocator();                                  
                                                                      
                                                                      
        if (status == HEAP_RESIZE_SUCCESSFUL)                         
          return RTEMS_SUCCESSFUL;                                    
a0018d14:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0018d18:	eaffffee 	b	a0018cd8 <rtems_region_resize_segment+0x58>     <== NOT EXECUTED
        _Region_Debug_Walk( the_region, 8 );                          
                                                                      
        if ( status == HEAP_RESIZE_SUCCESSFUL )                       
          _Region_Process_queue( the_region );    /* unlocks allocator */
        else                                                          
          _RTEMS_Unlock_allocator();                                  
a0018d1c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018d20:	eb000862 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
                                                                      
                                                                      
        if (status == HEAP_RESIZE_SUCCESSFUL)                         
          return RTEMS_SUCCESSFUL;                                    
        if (status == HEAP_RESIZE_UNSATISFIED)                        
          return RTEMS_UNSATISFIED;                                   
a0018d24:	e3560001 	cmp	r6, #1                                        <== NOT EXECUTED
a0018d28:	13a00009 	movne	r0, #9                                      <== NOT EXECUTED
a0018d2c:	03a0000d 	moveq	r0, #13                                     <== NOT EXECUTED
a0018d30:	eaffffe8 	b	a0018cd8 <rtems_region_resize_segment+0x58>     <== NOT EXECUTED
                                                                      

a0018d3c <rtems_region_return_segment>: rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) {
a0018d3c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  uint32_t                 size;                                      
#endif                                                                
  int                      status;                                    
  register Region_Control *the_region;                                
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018d40:	e59f4078 	ldr	r4, [pc, #120]	; a0018dc0 <rtems_region_return_segment+0x84><== NOT EXECUTED
                                                                      
rtems_status_code rtems_region_return_segment(                        
  rtems_id  id,                                                       
  void     *segment                                                   
)                                                                     
{                                                                     
a0018d44:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0018d48:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  uint32_t                 size;                                      
#endif                                                                
  int                      status;                                    
  register Region_Control *the_region;                                
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018d4c:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
                                                                      
rtems_status_code rtems_region_return_segment(                        
  rtems_id  id,                                                       
  void     *segment                                                   
)                                                                     
{                                                                     
a0018d50:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  uint32_t                 size;                                      
#endif                                                                
  int                      status;                                    
  register Region_Control *the_region;                                
                                                                      
  _RTEMS_Lock_allocator();                                            
a0018d54:	eb000839 	bl	a001ae40 <_API_Mutex_Lock>                     <== NOT EXECUTED
a0018d58:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0018d5c:	e59f0060 	ldr	r0, [pc, #96]	; a0018dc4 <rtems_region_return_segment+0x88><== NOT EXECUTED
a0018d60:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0018d64:	eb000fa2 	bl	a001cbf4 <_Objects_Get_no_protection>          <== NOT EXECUTED
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018d68:	e59d6000 	ldr	r6, [sp]                                      <== NOT EXECUTED
a0018d6c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0018d70:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
        break;                                                        
#endif                                                                
                                                                      
      case OBJECTS_ERROR:                                             
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
a0018d74:	13a06004 	movne	r6, #4                                      <== NOT EXECUTED
  register Region_Control *the_region;                                
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
    the_region = _Region_Get( id, &location );                        
    switch ( location ) {                                             
a0018d78:	1a000005 	bne	a0018d94 <rtems_region_return_segment+0x58>   <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (                      
  Region_Control *the_region,                                         
  void           *the_segment                                         
)                                                                     
{                                                                     
  return _Heap_Free( &the_region->Memory, the_segment );              
a0018d7c:	e2800068 	add	r0, r0, #104	; 0x68                           <== NOT EXECUTED
a0018d80:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0018d84:	eb000c2b 	bl	a001be38 <_Heap_Free>                          <== NOT EXECUTED
#endif                                                                
          status = _Region_Free_segment( the_region, segment );       
                                                                      
          _Region_Debug_Walk( the_region, 4 );                        
                                                                      
          if ( !status )                                              
a0018d88:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
            return_status = RTEMS_INVALID_ADDRESS;                    
a0018d8c:	03a06009 	moveq	r6, #9                                      <== NOT EXECUTED
#endif                                                                
          status = _Region_Free_segment( the_region, segment );       
                                                                      
          _Region_Debug_Walk( the_region, 4 );                        
                                                                      
          if ( !status )                                              
a0018d90:	1a000004 	bne	a0018da8 <rtems_region_return_segment+0x6c>   <== NOT EXECUTED
      default:                                                        
        return_status = RTEMS_INVALID_ID;                             
        break;                                                        
    }                                                                 
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0018d94:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0018d98:	eb000844 	bl	a001aeb0 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return return_status;                                               
}                                                                     
a0018d9c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0018da0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0018da4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
          _Region_Debug_Walk( the_region, 4 );                        
                                                                      
          if ( !status )                                              
            return_status = RTEMS_INVALID_ADDRESS;                    
          else {                                                      
            the_region->number_of_used_blocks -= 1;                   
a0018da8:	e5973064 	ldr	r3, [r7, #100]	; 0x64                         <== NOT EXECUTED
                                                                      
            _Region_Process_queue(the_region); /* unlocks allocator */
a0018dac:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
          _Region_Debug_Walk( the_region, 4 );                        
                                                                      
          if ( !status )                                              
            return_status = RTEMS_INVALID_ADDRESS;                    
          else {                                                      
            the_region->number_of_used_blocks -= 1;                   
a0018db0:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0018db4:	e5873064 	str	r3, [r7, #100]	; 0x64                         <== NOT EXECUTED
                                                                      
            _Region_Process_queue(the_region); /* unlocks allocator */
a0018db8:	eb001f02 	bl	a00209c8 <_Region_Process_queue>               <== NOT EXECUTED
                                                                      
            return RTEMS_SUCCESSFUL;                                  
a0018dbc:	eafffff6 	b	a0018d9c <rtems_region_return_segment+0x60>     <== NOT EXECUTED
                                                                      

a0009804 <rtems_semaphore_create>: uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) {
a0009804:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     
  register Semaphore_Control *the_semaphore;                          
  CORE_mutex_Attributes       the_mutex_attr;                         
  CORE_semaphore_Attributes   the_semaphore_attr;                     
  CORE_mutex_Status           mutex_status;                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0009808:	e2505000 	subs	r5, r0, #0                                   
  uint32_t             count,                                         
  rtems_attribute      attribute_set,                                 
  rtems_task_priority  priority_ceiling,                              
  rtems_id            *id                                             
)                                                                     
{                                                                     
a000980c:	e24dd020 	sub	sp, sp, #32                                   
a0009810:	e1a04001 	mov	r4, r1                                        
a0009814:	e59d6038 	ldr	r6, [sp, #56]	; 0x38                          
  CORE_mutex_Attributes       the_mutex_attr;                         
  CORE_semaphore_Attributes   the_semaphore_attr;                     
  CORE_mutex_Status           mutex_status;                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a0009818:	03a00003 	moveq	r0, #3                                      
  register Semaphore_Control *the_semaphore;                          
  CORE_mutex_Attributes       the_mutex_attr;                         
  CORE_semaphore_Attributes   the_semaphore_attr;                     
  CORE_mutex_Status           mutex_status;                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000981c:	0a000008 	beq	a0009844 <rtems_semaphore_create+0x40>        
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a0009820:	e3560000 	cmp	r6, #0                                        
    return RTEMS_INVALID_ADDRESS;                                     
a0009824:	03a00009 	moveq	r0, #9                                      
  CORE_mutex_Status           mutex_status;                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a0009828:	0a000005 	beq	a0009844 <rtems_semaphore_create+0x40>        
      return RTEMS_NOT_DEFINED;                                       
                                                                      
  } else                                                              
#endif                                                                
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) ||            
a000982c:	e21210c0 	ands	r1, r2, #192	; 0xc0                          
a0009830:	0a000037 	beq	a0009914 <rtems_semaphore_create+0x110>       
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(            
  rtems_attribute attribute_set                                       
)                                                                     
{                                                                     
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
a0009834:	e2028030 	and	r8, r2, #48	; 0x30                            
              _Attributes_Is_priority_ceiling( attribute_set ) ) {    
                                                                      
    if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&       
a0009838:	e3580010 	cmp	r8, #16                                       
a000983c:	0a000002 	beq	a000984c <rtems_semaphore_create+0x48>        
                                                                      
  }                                                                   
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) &&            
       _Attributes_Is_priority_ceiling( attribute_set ) )             
    return RTEMS_NOT_DEFINED;                                         
a0009840:	e3a0000b 	mov	r0, #11                                       <== NOT EXECUTED
      0                          /* Not used */                       
    );                                                                
#endif                                                                
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009844:	e28dd020 	add	sp, sp, #32                                   
a0009848:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      
#endif                                                                
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) ||            
              _Attributes_Is_priority_ceiling( attribute_set ) ) {    
                                                                      
    if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&       
a000984c:	e3120004 	tst	r2, #4                                        
a0009850:	0afffffa 	beq	a0009840 <rtems_semaphore_create+0x3c>        
            _Attributes_Is_priority( attribute_set ) ) )              
      return RTEMS_NOT_DEFINED;                                       
                                                                      
  }                                                                   
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) &&            
a0009854:	e35100c0 	cmp	r1, #192	; 0xc0                               
a0009858:	0afffff8 	beq	a0009840 <rtems_semaphore_create+0x3c>        
       _Attributes_Is_priority_ceiling( attribute_set ) )             
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
a000985c:	e3540001 	cmp	r4, #1                                        
    return RTEMS_INVALID_NUMBER;                                      
a0009860:	83a0000a 	movhi	r0, #10                                     
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) &&            
       _Attributes_Is_priority_ceiling( attribute_set ) )             
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
a0009864:	8afffff6 	bhi	a0009844 <rtems_semaphore_create+0x40>        
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a0009868:	e59f1150 	ldr	r1, [pc, #336]	; a00099c0 <rtems_semaphore_create+0x1bc>
a000986c:	e5910000 	ldr	r0, [r1]                                      
a0009870:	e2800001 	add	r0, r0, #1                                    
a0009874:	e5810000 	str	r0, [r1]                                      
 *  This function allocates a semaphore control block from            
 *  the inactive chain of free semaphore control blocks.              
 */                                                                   
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )   
{                                                                     
  return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
a0009878:	e59f0144 	ldr	r0, [pc, #324]	; a00099c4 <rtems_semaphore_create+0x1c0>
a000987c:	e58d2004 	str	r2, [sp, #4]                                  
a0009880:	e58d3000 	str	r3, [sp]                                      
a0009884:	eb00054b 	bl	a000adb8 <_Objects_Allocate>                   
                                                                      
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_semaphore = _Semaphore_Allocate();                              
                                                                      
  if ( !the_semaphore ) {                                             
a0009888:	e2507000 	subs	r7, r0, #0                                   
a000988c:	e59d2004 	ldr	r2, [sp, #4]                                  
a0009890:	e59d3000 	ldr	r3, [sp]                                      
a0009894:	0a00002f 	beq	a0009958 <rtems_semaphore_create+0x154>       
  the_semaphore->attribute_set = attribute_set;                       
                                                                      
  /*                                                                  
   *  Initialize it as a counting semaphore.                          
   */                                                                 
  if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {         
a0009898:	e3580000 	cmp	r8, #0                                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_semaphore->attribute_set = attribute_set;                       
a000989c:	e5872010 	str	r2, [r7, #16]                                 
                                                                      
  /*                                                                  
   *  Initialize it as a counting semaphore.                          
   */                                                                 
  if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {         
a00098a0:	0a00001e 	beq	a0009920 <rtems_semaphore_create+0x11c>       
  } else {                                                            
    /*                                                                
     *  It is either simple binary semaphore or a more powerful mutex 
     *  style binary semaphore.  This is the mutex style.             
     */                                                               
    if ( _Attributes_Is_priority( attribute_set ) )                   
a00098a4:	e2121004 	ands	r1, r2, #4                                   
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;    
a00098a8:	13a01001 	movne	r1, #1                                      
a00098ac:	158d1010 	strne	r1, [sp, #16]                               
    else                                                              
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;        
a00098b0:	058d1010 	streq	r1, [sp, #16]                               
                                                                      
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
a00098b4:	e3580010 	cmp	r8, #16                                       
a00098b8:	0a000029 	beq	a0009964 <rtems_semaphore_create+0x160>       
          the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
          the_mutex_attr.only_owner_release = true;                   
        }                                                             
      }                                                               
    } else /* must be simple binary semaphore */ {                    
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
a00098bc:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a00098c0:	e58d3008 	str	r3, [sp, #8]                                  <== NOT EXECUTED
      the_mutex_attr.only_owner_release = false;                      
a00098c4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00098c8:	e5cd300c 	strb	r3, [sp, #12]                                <== NOT EXECUTED
    }                                                                 
                                                                      
    mutex_status = _CORE_mutex_Initialize(                            
a00098cc:	e3540001 	cmp	r4, #1                                        
a00098d0:	13a02000 	movne	r2, #0                                      
a00098d4:	03a02001 	moveq	r2, #1                                      
a00098d8:	e2870014 	add	r0, r7, #20                                   
a00098dc:	e28d1008 	add	r1, sp, #8                                    
a00098e0:	eb0002e2 	bl	a000a470 <_CORE_mutex_Initialize>              
      &the_semaphore->Core_control.mutex,                             
      &the_mutex_attr,                                                
      (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED          
    );                                                                
                                                                      
    if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {       
a00098e4:	e3500005 	cmp	r0, #5                                        
a00098e8:	0a00002e 	beq	a00099a8 <rtems_semaphore_create+0x1a4>       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a00098ec:	e59f20d0 	ldr	r2, [pc, #208]	; a00099c4 <rtems_semaphore_create+0x1c0>
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a00098f0:	e5973008 	ldr	r3, [r7, #8]                                  
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a00098f4:	e592201c 	ldr	r2, [r2, #28]                                 
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a00098f8:	e1a01803 	lsl	r1, r3, #16                                   
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a00098fc:	e7827721 	str	r7, [r2, r1, lsr #14]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a0009900:	e587500c 	str	r5, [r7, #12]                                 
    &_Semaphore_Information,                                          
    &the_semaphore->Object,                                           
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_semaphore->Object.id;                                     
a0009904:	e5863000 	str	r3, [r6]                                      
      the_semaphore->Object.id,                                       
      name,                                                           
      0                          /* Not used */                       
    );                                                                
#endif                                                                
  _Thread_Enable_dispatch();                                          
a0009908:	eb0009b0 	bl	a000bfd0 <_Thread_Enable_dispatch>             
  return RTEMS_SUCCESSFUL;                                            
a000990c:	e3a00000 	mov	r0, #0                                        
a0009910:	eaffffcb 	b	a0009844 <rtems_semaphore_create+0x40>          
                                                                      
  if ( _Attributes_Is_inherit_priority( attribute_set ) &&            
       _Attributes_Is_priority_ceiling( attribute_set ) )             
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
a0009914:	e2128030 	ands	r8, r2, #48	; 0x30                           
a0009918:	1affffcf 	bne	a000985c <rtems_semaphore_create+0x58>        
a000991c:	eaffffd1 	b	a0009868 <rtems_semaphore_create+0x64>          
    /*                                                                
     *  This effectively disables limit checking.                     
     */                                                               
    the_semaphore_attr.maximum_count = 0xFFFFFFFF;                    
                                                                      
    if ( _Attributes_Is_priority( attribute_set ) )                   
a0009920:	e3120004 	tst	r2, #4                                        
   */                                                                 
  if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {         
    /*                                                                
     *  This effectively disables limit checking.                     
     */                                                               
    the_semaphore_attr.maximum_count = 0xFFFFFFFF;                    
a0009924:	e3e03000 	mvn	r3, #0                                        
a0009928:	e58d3018 	str	r3, [sp, #24]                                 
                                                                      
    if ( _Attributes_Is_priority( attribute_set ) )                   
      the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
a000992c:	13a03001 	movne	r3, #1                                      
a0009930:	158d301c 	strne	r3, [sp, #28]                               
     *  The following are just to make Purify happy.                  
     */                                                               
    the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;               
                                                                      
    _CORE_semaphore_Initialize(                                       
a0009934:	e2870014 	add	r0, r7, #20                                   
      the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
                                                                      
    /*                                                                
     *  The following are just to make Purify happy.                  
     */                                                               
    the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
a0009938:	e3a03000 	mov	r3, #0                                        
    the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;               
                                                                      
    _CORE_semaphore_Initialize(                                       
a000993c:	e28d1018 	add	r1, sp, #24                                   
a0009940:	e1a02004 	mov	r2, r4                                        
    the_semaphore_attr.maximum_count = 0xFFFFFFFF;                    
                                                                      
    if ( _Attributes_Is_priority( attribute_set ) )                   
      the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
    else                                                              
      the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
a0009944:	058d801c 	streq	r8, [sp, #28]                               
                                                                      
    /*                                                                
     *  The following are just to make Purify happy.                  
     */                                                               
    the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
a0009948:	e58d3008 	str	r3, [sp, #8]                                  
    the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;               
a000994c:	e58d3014 	str	r3, [sp, #20]                                 
                                                                      
    _CORE_semaphore_Initialize(                                       
a0009950:	eb000395 	bl	a000a7ac <_CORE_semaphore_Initialize>          
a0009954:	eaffffe4 	b	a00098ec <rtems_semaphore_create+0xe8>          
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_semaphore = _Semaphore_Allocate();                              
                                                                      
  if ( !the_semaphore ) {                                             
    _Thread_Enable_dispatch();                                        
a0009958:	eb00099c 	bl	a000bfd0 <_Thread_Enable_dispatch>             
    return RTEMS_TOO_MANY;                                            
a000995c:	e3a00005 	mov	r0, #5                                        
a0009960:	eaffffb7 	b	a0009844 <rtems_semaphore_create+0x40>          
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
      the_mutex_attr.priority_ceiling      = priority_ceiling;        
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
      the_mutex_attr.only_owner_release    = false;                   
                                                                      
      if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
a0009964:	e59d0010 	ldr	r0, [sp, #16]                                 
    else                                                              
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;        
                                                                      
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
      the_mutex_attr.priority_ceiling      = priority_ceiling;        
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
a0009968:	e3a01000 	mov	r1, #0                                        
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;    
    else                                                              
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;        
                                                                      
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
      the_mutex_attr.priority_ceiling      = priority_ceiling;        
a000996c:	e58d3014 	str	r3, [sp, #20]                                 
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
      the_mutex_attr.only_owner_release    = false;                   
                                                                      
      if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
a0009970:	e3500001 	cmp	r0, #1                                        
    else                                                              
      the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;        
                                                                      
    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {         
      the_mutex_attr.priority_ceiling      = priority_ceiling;        
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
a0009974:	e58d1008 	str	r1, [sp, #8]                                  
      the_mutex_attr.only_owner_release    = false;                   
a0009978:	e5cd100c 	strb	r1, [sp, #12]                                
                                                                      
      if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
a000997c:	1affffd2 	bne	a00098cc <rtems_semaphore_create+0xc8>        
        if ( _Attributes_Is_inherit_priority( attribute_set ) ) {     
a0009980:	e3120040 	tst	r2, #64	; 0x40                                
          the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
a0009984:	13a03002 	movne	r3, #2                                      
a0009988:	158d3010 	strne	r3, [sp, #16]                               
          the_mutex_attr.only_owner_release = true;                   
a000998c:	15cd000c 	strbne	r0, [sp, #12]                              
      the_mutex_attr.priority_ceiling      = priority_ceiling;        
      the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
      the_mutex_attr.only_owner_release    = false;                   
                                                                      
      if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
        if ( _Attributes_Is_inherit_priority( attribute_set ) ) {     
a0009990:	1affffcd 	bne	a00098cc <rtems_semaphore_create+0xc8>        
          the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
          the_mutex_attr.only_owner_release = true;                   
        } else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
a0009994:	e3120080 	tst	r2, #128	; 0x80                               <== NOT EXECUTED
          the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
a0009998:	13a03003 	movne	r3, #3                                      <== NOT EXECUTED
a000999c:	158d3010 	strne	r3, [sp, #16]                               <== NOT EXECUTED
          the_mutex_attr.only_owner_release = true;                   
a00099a0:	15cd000c 	strbne	r0, [sp, #12]                              <== NOT EXECUTED
a00099a4:	eaffffc8 	b	a00098cc <rtems_semaphore_create+0xc8>          <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Semaphore_Free (                           
  Semaphore_Control *the_semaphore                                    
)                                                                     
{                                                                     
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );   
a00099a8:	e59f0014 	ldr	r0, [pc, #20]	; a00099c4 <rtems_semaphore_create+0x1c0><== NOT EXECUTED
a00099ac:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a00099b0:	eb0005da 	bl	a000b120 <_Objects_Free>                       <== NOT EXECUTED
      (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED          
    );                                                                
                                                                      
    if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {       
      _Semaphore_Free( the_semaphore );                               
      _Thread_Enable_dispatch();                                      
a00099b4:	eb000985 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INVALID_PRIORITY;                                  
a00099b8:	e3a00013 	mov	r0, #19                                       <== NOT EXECUTED
a00099bc:	eaffffa0 	b	a0009844 <rtems_semaphore_create+0x40>          <== NOT EXECUTED
                                                                      

a00099c8 <rtems_semaphore_delete>: #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) {
a00099c8:	e92d4010 	push	{r4, lr}                                     
a00099cc:	e24dd004 	sub	sp, sp, #4                                    
a00099d0:	e1a01000 	mov	r1, r0                                        
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Semaphore_Control *)                                        
    _Objects_Get( &_Semaphore_Information, id, location );            
a00099d4:	e1a0200d 	mov	r2, sp                                        
a00099d8:	e59f0088 	ldr	r0, [pc, #136]	; a0009a68 <rtems_semaphore_delete+0xa0>
a00099dc:	eb000628 	bl	a000b284 <_Objects_Get>                        
  register Semaphore_Control *the_semaphore;                          
  Objects_Locations           location;                               
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a00099e0:	e59d3000 	ldr	r3, [sp]                                      
a00099e4:	e1a04000 	mov	r4, r0                                        
a00099e8:	e3530000 	cmp	r3, #0                                        
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00099ec:	13a00004 	movne	r0, #4                                      
{                                                                     
  register Semaphore_Control *the_semaphore;                          
  Objects_Locations           location;                               
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a00099f0:	1a000009 	bne	a0009a1c <rtems_semaphore_delete+0x54>        
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(          
  rtems_attribute attribute_set                                       
)                                                                     
{                                                                     
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
a00099f4:	e5941010 	ldr	r1, [r4, #16]                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
a00099f8:	e2111030 	ands	r1, r1, #48	; 0x30                           
a00099fc:	0a000015 	beq	a0009a58 <rtems_semaphore_delete+0x90>        
        if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
a0009a00:	e5943064 	ldr	r3, [r4, #100]	; 0x64                         
a0009a04:	e3530000 	cmp	r3, #0                                        
a0009a08:	1a000005 	bne	a0009a24 <rtems_semaphore_delete+0x5c>        
a0009a0c:	e3510020 	cmp	r1, #32                                       <== NOT EXECUTED
a0009a10:	0a000003 	beq	a0009a24 <rtems_semaphore_delete+0x5c>        <== NOT EXECUTED
             !_Attributes_Is_simple_binary_semaphore(                 
                 the_semaphore->attribute_set ) ) {                   
          _Thread_Enable_dispatch();                                  
a0009a14:	eb00096d 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_RESOURCE_IN_USE;                               
a0009a18:	e3a0000c 	mov	r0, #12                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009a1c:	e28dd004 	add	sp, sp, #4                                    
a0009a20:	e8bd8010 	pop	{r4, pc}                                      
             !_Attributes_Is_simple_binary_semaphore(                 
                 the_semaphore->attribute_set ) ) {                   
          _Thread_Enable_dispatch();                                  
          return RTEMS_RESOURCE_IN_USE;                               
        }                                                             
        _CORE_mutex_Flush(                                            
a0009a24:	e2840014 	add	r0, r4, #20                                   
a0009a28:	e3a01000 	mov	r1, #0                                        
a0009a2c:	e3a02003 	mov	r2, #3                                        
a0009a30:	eb00028d 	bl	a000a46c <_CORE_mutex_Flush>                   
          SEMAPHORE_MP_OBJECT_WAS_DELETED,                            
          CORE_SEMAPHORE_WAS_DELETED                                  
        );                                                            
     }                                                                
                                                                      
      _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
a0009a34:	e1a01004 	mov	r1, r4                                        
a0009a38:	e59f0028 	ldr	r0, [pc, #40]	; a0009a68 <rtems_semaphore_delete+0xa0>
a0009a3c:	eb000502 	bl	a000ae4c <_Objects_Close>                      
 */                                                                   
RTEMS_INLINE_ROUTINE void _Semaphore_Free (                           
  Semaphore_Control *the_semaphore                                    
)                                                                     
{                                                                     
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );   
a0009a40:	e59f0020 	ldr	r0, [pc, #32]	; a0009a68 <rtems_semaphore_delete+0xa0>
a0009a44:	e1a01004 	mov	r1, r4                                        
a0009a48:	eb0005b4 	bl	a000b120 <_Objects_Free>                       
          0,                         /* Not used */                   
          0                          /* Not used */                   
        );                                                            
      }                                                               
#endif                                                                
      _Thread_Enable_dispatch();                                      
a0009a4c:	eb00095f 	bl	a000bfd0 <_Thread_Enable_dispatch>             
      return RTEMS_SUCCESSFUL;                                        
a0009a50:	e3a00000 	mov	r0, #0                                        
a0009a54:	eafffff0 	b	a0009a1c <rtems_semaphore_delete+0x54>          
          &the_semaphore->Core_control.mutex,                         
          SEMAPHORE_MP_OBJECT_WAS_DELETED,                            
          CORE_MUTEX_WAS_DELETED                                      
        );                                                            
      } else {                                                        
        _CORE_semaphore_Flush(                                        
a0009a58:	e2840014 	add	r0, r4, #20                                   
a0009a5c:	e3a02002 	mov	r2, #2                                        
a0009a60:	eb000350 	bl	a000a7a8 <_CORE_semaphore_Flush>               
a0009a64:	eafffff2 	b	a0009a34 <rtems_semaphore_delete+0x6c>          
                                                                      

a0012b30 <rtems_semaphore_flush>: #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) {
a0012b30:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0012b34:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0012b38:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0012b3c:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0012b40:	e59f004c 	ldr	r0, [pc, #76]	; a0012b94 <rtems_semaphore_flush+0x64><== NOT EXECUTED
a0012b44:	ebffe680 	bl	a000c54c <_Objects_Get>                        <== NOT EXECUTED
  register Semaphore_Control *the_semaphore;                          
  Objects_Locations           location;                               
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a0012b48:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0012b4c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0012b50:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Semaphore_Control *the_semaphore;                          
  Objects_Locations           location;                               
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a0012b54:	1a000007 	bne	a0012b78 <rtems_semaphore_flush+0x48>         <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(          
  rtems_attribute attribute_set                                       
)                                                                     
{                                                                     
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
a0012b58:	e5901010 	ldr	r1, [r0, #16]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
a0012b5c:	e2111030 	ands	r1, r1, #48	; 0x30                           <== NOT EXECUTED
a0012b60:	1a000006 	bne	a0012b80 <rtems_semaphore_flush+0x50>         <== NOT EXECUTED
          &the_semaphore->Core_control.mutex,                         
          SEND_OBJECT_WAS_DELETED,                                    
          CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT                        
        );                                                            
      } else {                                                        
        _CORE_semaphore_Flush(                                        
a0012b64:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0012b68:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0012b6c:	ebffe3df 	bl	a000baf0 <_CORE_semaphore_Flush>               <== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,                     
          SEND_OBJECT_WAS_DELETED,                                    
          CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT                    
        );                                                            
      }                                                               
      _Thread_Enable_dispatch();                                      
a0012b70:	ebffe9ce 	bl	a000d2b0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0012b74:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0012b78:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0012b7c:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
        _CORE_mutex_Flush(                                            
a0012b80:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0012b84:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0012b88:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0012b8c:	ebffe308 	bl	a000b7b4 <_CORE_mutex_Flush>                   <== NOT EXECUTED
a0012b90:	eafffff6 	b	a0012b70 <rtems_semaphore_flush+0x40>           <== NOT EXECUTED
                                                                      

a0019098 <rtems_semaphore_ident>: rtems_status_code rtems_semaphore_ident( rtems_name name, uint32_t node, rtems_id *id ) {
a0019098:	e1a0c001 	mov	ip, r1                                        <== NOT EXECUTED
a001909c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a00190a0:	e1a0e000 	mov	lr, r0                                        <== NOT EXECUTED
a00190a4:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32( &_Semaphore_Information, name, node, id );
a00190a8:	e1a0100e 	mov	r1, lr                                        <== NOT EXECUTED
a00190ac:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
a00190b0:	e59f000c 	ldr	r0, [pc, #12]	; a00190c4 <rtems_semaphore_ident+0x2c><== NOT EXECUTED
a00190b4:	eb000f33 	bl	a001cd88 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a00190b8:	e59f3008 	ldr	r3, [pc, #8]	; a00190c8 <rtems_semaphore_ident+0x30><== NOT EXECUTED
}                                                                     
a00190bc:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a00190c0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0009a6c <rtems_semaphore_obtain>: rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) {
a0009a6c:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         
a0009a70:	e1a04000 	mov	r4, r0                                        
a0009a74:	e24dd00c 	sub	sp, sp, #12                                   
  Objects_Locations *location,                                        
  ISR_Level         *level                                            
)                                                                     
{                                                                     
  return (Semaphore_Control *)                                        
    _Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
a0009a78:	e28d3004 	add	r3, sp, #4                                    
a0009a7c:	e1a05001 	mov	r5, r1                                        
a0009a80:	e1a06002 	mov	r6, r2                                        
a0009a84:	e59f00f4 	ldr	r0, [pc, #244]	; a0009b80 <rtems_semaphore_obtain+0x114>
a0009a88:	e1a01004 	mov	r1, r4                                        
a0009a8c:	e28d2008 	add	r2, sp, #8                                    
a0009a90:	eb0005df 	bl	a000b214 <_Objects_Get_isr_disable>            
  register Semaphore_Control     *the_semaphore;                      
  Objects_Locations               location;                           
  ISR_Level                       level;                              
                                                                      
  the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
  switch ( location ) {                                               
a0009a94:	e59d3008 	ldr	r3, [sp, #8]                                  
a0009a98:	e3530000 	cmp	r3, #0                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
                                                                      
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0009a9c:	13a00004 	movne	r0, #4                                      
  register Semaphore_Control     *the_semaphore;                      
  Objects_Locations               location;                           
  ISR_Level                       level;                              
                                                                      
  the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
  switch ( location ) {                                               
a0009aa0:	1a00000e 	bne	a0009ae0 <rtems_semaphore_obtain+0x74>        
a0009aa4:	e5903010 	ldr	r3, [r0, #16]                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
a0009aa8:	e2133030 	ands	r3, r3, #48	; 0x30                           
a0009aac:	0a00000d 	beq	a0009ae8 <rtems_semaphore_obtain+0x7c>        
        _CORE_mutex_Seize(                                            
a0009ab0:	e59d3004 	ldr	r3, [sp, #4]                                  
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (                       
  rtems_option option_set                                             
)                                                                     
{                                                                     
   return (option_set & RTEMS_NO_WAIT) ? true : false;                
a0009ab4:	e2052001 	and	r2, r5, #1                                    
a0009ab8:	e2800014 	add	r0, r0, #20                                   
a0009abc:	e58d3000 	str	r3, [sp]                                      
a0009ac0:	e2222001 	eor	r2, r2, #1                                    
a0009ac4:	e1a03006 	mov	r3, r6                                        
a0009ac8:	e1a01004 	mov	r1, r4                                        
a0009acc:	eb0002b1 	bl	a000a598 <_CORE_mutex_Seize>                   
          ((_Options_Is_no_wait( option_set )) ? false : true),       
          timeout,                                                    
          level                                                       
        );                                                            
        return _Semaphore_Translate_core_mutex_return_code(           
                  _Thread_Executing->Wait.return_code );              
a0009ad0:	e59f30ac 	ldr	r3, [pc, #172]	; a0009b84 <rtems_semaphore_obtain+0x118>
a0009ad4:	e5933004 	ldr	r3, [r3, #4]                                  
          id,                                                         
          ((_Options_Is_no_wait( option_set )) ? false : true),       
          timeout,                                                    
          level                                                       
        );                                                            
        return _Semaphore_Translate_core_mutex_return_code(           
a0009ad8:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          
a0009adc:	eb00004c 	bl	a0009c14 <_Semaphore_Translate_core_mutex_return_code>
      break;                                                          
                                                                      
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009ae0:	e28dd00c 	add	sp, sp, #12                                   
a0009ae4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          
{                                                                     
  Thread_Control *executing;                                          
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
a0009ae8:	e59f7094 	ldr	r7, [pc, #148]	; a0009b84 <rtems_semaphore_obtain+0x118><== NOT EXECUTED
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;     
  if ( the_semaphore->count != 0 ) {                                  
a0009aec:	e590105c 	ldr	r1, [r0, #92]	; 0x5c                          <== NOT EXECUTED
{                                                                     
  Thread_Control *executing;                                          
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
a0009af0:	e5972004 	ldr	r2, [r7, #4]                                  <== NOT EXECUTED
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;     
  if ( the_semaphore->count != 0 ) {                                  
a0009af4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
  Thread_Control *executing;                                          
                                                                      
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;     
a0009af8:	e5823034 	str	r3, [r2, #52]	; 0x34                          <== NOT EXECUTED
  if ( the_semaphore->count != 0 ) {                                  
a0009afc:	1a000009 	bne	a0009b28 <rtems_semaphore_obtain+0xbc>        <== NOT EXECUTED
    the_semaphore->count -= 1;                                        
    _ISR_Enable( *level_p );                                          
    return;                                                           
  }                                                                   
                                                                      
  if ( !wait ) {                                                      
a0009b00:	e3150001 	tst	r5, #1                                        <== NOT EXECUTED
a0009b04:	0a00000c 	beq	a0009b3c <rtems_semaphore_obtain+0xd0>        <== NOT EXECUTED
a0009b08:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0009b0c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    _ISR_Enable( *level_p );                                          
    executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
a0009b10:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0009b14:	e5823034 	str	r3, [r2, #52]	; 0x34                          <== NOT EXECUTED
        ((_Options_Is_no_wait( option_set )) ? false : true),         
        timeout,                                                      
        &level                                                        
      );                                                              
      return _Semaphore_Translate_core_semaphore_return_code(         
                  _Thread_Executing->Wait.return_code );              
a0009b18:	e5973004 	ldr	r3, [r7, #4]                                  <== NOT EXECUTED
        id,                                                           
        ((_Options_Is_no_wait( option_set )) ? false : true),         
        timeout,                                                      
        &level                                                        
      );                                                              
      return _Semaphore_Translate_core_semaphore_return_code(         
a0009b1c:	e5930034 	ldr	r0, [r3, #52]	; 0x34                          <== NOT EXECUTED
a0009b20:	eb00003f 	bl	a0009c24 <_Semaphore_Translate_core_semaphore_return_code><== NOT EXECUTED
a0009b24:	eaffffed 	b	a0009ae0 <rtems_semaphore_obtain+0x74>          <== NOT EXECUTED
  /* disabled when you get here */                                    
                                                                      
  executing = _Thread_Executing;                                      
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;     
  if ( the_semaphore->count != 0 ) {                                  
    the_semaphore->count -= 1;                                        
a0009b28:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
a0009b2c:	e580105c 	str	r1, [r0, #92]	; 0x5c                          <== NOT EXECUTED
a0009b30:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0009b34:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
a0009b38:	eafffff6 	b	a0009b18 <rtems_semaphore_obtain+0xac>          <== NOT EXECUTED
a0009b3c:	e59f3044 	ldr	r3, [pc, #68]	; a0009b88 <rtems_semaphore_obtain+0x11c><== NOT EXECUTED
a0009b40:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a0009b44:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
a0009b48:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (      
  Thread_queue_Control *the_thread_queue                              
)                                                                     
{                                                                     
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a0009b4c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    return;                                                           
  }                                                                   
                                                                      
  _Thread_Disable_dispatch();                                         
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); 
  executing->Wait.queue          = &the_semaphore->Wait_queue;        
a0009b50:	e2803014 	add	r3, r0, #20                                   <== NOT EXECUTED
a0009b54:	e5801044 	str	r1, [r0, #68]	; 0x44                          <== NOT EXECUTED
a0009b58:	e5823044 	str	r3, [r2, #68]	; 0x44                          <== NOT EXECUTED
  executing->Wait.id             = id;                                
a0009b5c:	e5824020 	str	r4, [r2, #32]                                 <== NOT EXECUTED
a0009b60:	e59d2004 	ldr	r2, [sp, #4]                                  <== NOT EXECUTED
a0009b64:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
  _ISR_Enable( *level_p );                                            
                                                                      
  _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );       
a0009b68:	e59f201c 	ldr	r2, [pc, #28]	; a0009b8c <rtems_semaphore_obtain+0x120><== NOT EXECUTED
a0009b6c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0009b70:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0009b74:	eb000a32 	bl	a000c444 <_Thread_queue_Enqueue_with_handler>  <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a0009b78:	eb000914 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
a0009b7c:	eaffffe5 	b	a0009b18 <rtems_semaphore_obtain+0xac>          <== NOT EXECUTED
                                                                      

a0009b90 <rtems_semaphore_release>: #endif rtems_status_code rtems_semaphore_release( rtems_id id ) {
a0009b90:	e92d4010 	push	{r4, lr}                                     
a0009b94:	e24dd004 	sub	sp, sp, #4                                    
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Semaphore_Control *)                                        
    _Objects_Get( &_Semaphore_Information, id, location );            
a0009b98:	e1a01000 	mov	r1, r0                                        
a0009b9c:	e1a04000 	mov	r4, r0                                        
a0009ba0:	e1a0200d 	mov	r2, sp                                        
a0009ba4:	e59f0064 	ldr	r0, [pc, #100]	; a0009c10 <rtems_semaphore_release+0x80>
a0009ba8:	eb0005b5 	bl	a000b284 <_Objects_Get>                        
  Objects_Locations           location;                               
  CORE_mutex_Status           mutex_status;                           
  CORE_semaphore_Status       semaphore_status;                       
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a0009bac:	e59d3000 	ldr	r3, [sp]                                      
a0009bb0:	e3530000 	cmp	r3, #0                                        
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0009bb4:	13a00004 	movne	r0, #4                                      
  Objects_Locations           location;                               
  CORE_mutex_Status           mutex_status;                           
  CORE_semaphore_Status       semaphore_status;                       
                                                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
a0009bb8:	1a000009 	bne	a0009be4 <rtems_semaphore_release+0x54>       
a0009bbc:	e5902010 	ldr	r2, [r0, #16]                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
a0009bc0:	e2122030 	ands	r2, r2, #48	; 0x30                           
a0009bc4:	1a000008 	bne	a0009bec <rtems_semaphore_release+0x5c>       
          MUTEX_MP_SUPPORT                                            
        );                                                            
        _Thread_Enable_dispatch();                                    
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
      } else {                                                        
        semaphore_status = _CORE_semaphore_Surrender(                 
a0009bc8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0009bcc:	e2800014 	add	r0, r0, #20                                   <== NOT EXECUTED
a0009bd0:	eb000302 	bl	a000a7e0 <_CORE_semaphore_Surrender>           <== NOT EXECUTED
a0009bd4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,                     
          id,                                                         
          MUTEX_MP_SUPPORT                                            
        );                                                            
        _Thread_Enable_dispatch();                                    
a0009bd8:	eb0008fc 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return                                                        
a0009bdc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009be0:	eb00000f 	bl	a0009c24 <_Semaphore_Translate_core_semaphore_return_code><== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009be4:	e28dd004 	add	sp, sp, #4                                    
a0009be8:	e8bd8010 	pop	{r4, pc}                                      
  the_semaphore = _Semaphore_Get( id, &location );                    
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
        mutex_status = _CORE_mutex_Surrender(                         
a0009bec:	e1a01004 	mov	r1, r4                                        
a0009bf0:	e1a02003 	mov	r2, r3                                        
a0009bf4:	e2800014 	add	r0, r0, #20                                   
a0009bf8:	eb000299 	bl	a000a664 <_CORE_mutex_Surrender>               
a0009bfc:	e1a04000 	mov	r4, r0                                        
          &the_semaphore->Core_control.mutex,                         
          id,                                                         
          MUTEX_MP_SUPPORT                                            
        );                                                            
        _Thread_Enable_dispatch();                                    
a0009c00:	eb0008f2 	bl	a000bfd0 <_Thread_Enable_dispatch>             
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
a0009c04:	e1a00004 	mov	r0, r4                                        
a0009c08:	eb000001 	bl	a0009c14 <_Semaphore_Translate_core_mutex_return_code>
a0009c0c:	eafffff4 	b	a0009be4 <rtems_semaphore_release+0x54>         
                                                                      

a00161b4 <rtems_shutdown_executive>: void rtems_shutdown_executive( uint32_t result ) { if ( _System_state_Is_up( _System_state_Get() ) ) {
a00161b4:	e59f302c 	ldr	r3, [pc, #44]	; a00161e8 <rtems_shutdown_executive+0x34>
 */                                                                   
                                                                      
void rtems_shutdown_executive(                                        
   uint32_t   result                                                  
)                                                                     
{                                                                     
a00161b8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
a00161bc:	e5932000 	ldr	r2, [r3]                                      
a00161c0:	e3520003 	cmp	r2, #3                                        
a00161c4:	0a000003 	beq	a00161d8 <rtems_shutdown_executive+0x24>      
    _System_state_Set( SYSTEM_STATE_SHUTDOWN );                       
    _Thread_Stop_multitasking();                                      
  }                                                                   
  _Internal_error_Occurred(                                           
a00161c8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a00161cc:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00161d0:	e3a02014 	mov	r2, #20                                       <== NOT EXECUTED
a00161d4:	ebffd2df 	bl	a000ad58 <_Internal_error_Occurred>            <== NOT EXECUTED
a00161d8:	e3a02004 	mov	r2, #4                                        
   *  if we were running within the same context, it would work.      
   *                                                                  
   *  And we will not return to this thread, so there is no point of  
   *  saving the context.                                             
   */                                                                 
  _Context_Restart_self( &_Thread_BSP_context );                      
a00161dc:	e59f0008 	ldr	r0, [pc, #8]	; a00161ec <rtems_shutdown_executive+0x38>
a00161e0:	e5832000 	str	r2, [r3]                                      
a00161e4:	ebffdcba 	bl	a000d4d4 <_CPU_Context_restore>                
                                                                      

a000ae78 <rtems_signal_catch>:
a000ae78:	e59f3048 	ldr	r3, [pc, #72]	; a000aec8 <rtems_signal_catch+0x50><== NOT EXECUTED
  RTEMS_API_Control  *api;                                            
  ASR_Information    *asr;                                            
                                                                      
/* XXX normalize mode */                                              
  executing = _Thread_Executing;                                      
  api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
a000ae7c:	e59f2048 	ldr	r2, [pc, #72]	; a000aecc <rtems_signal_catch+0x54><== NOT EXECUTED
                                                                      
rtems_status_code rtems_signal_catch(                                 
  rtems_asr_entry   asr_handler,                                      
  rtems_mode        mode_set                                          
)                                                                     
{                                                                     
a000ae80:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a000ae84:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
  RTEMS_API_Control  *api;                                            
  ASR_Information    *asr;                                            
                                                                      
/* XXX normalize mode */                                              
  executing = _Thread_Executing;                                      
  api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
a000ae88:	e5922004 	ldr	r2, [r2, #4]                                  <== NOT EXECUTED
a000ae8c:	e28cc001 	add	ip, ip, #1                                    <== NOT EXECUTED
a000ae90:	e59220f4 	ldr	r2, [r2, #244]	; 0xf4                         <== NOT EXECUTED
a000ae94:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
  asr = &api->Signal;                                                 
                                                                      
  _Thread_Disable_dispatch(); /* cannot reschedule while */           
                              /*   the thread is inconsistent */      
                                                                      
  if ( !_ASR_Is_null_handler( asr_handler ) ) {                       
a000ae98:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    asr->mode_set = mode_set;                                         
    asr->handler = asr_handler;                                       
a000ae9c:	1582000c 	strne	r0, [r2, #12]                               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _ASR_Initialize (                           
  ASR_Information *information                                        
)                                                                     
{                                                                     
  information->is_enabled      = false;                               
a000aea0:	05c20008 	strbeq	r0, [r2, #8]                               <== NOT EXECUTED
  information->handler         = NULL;                                
a000aea4:	0582000c 	streq	r0, [r2, #12]                               <== NOT EXECUTED
  information->mode_set        = RTEMS_DEFAULT_MODES;                 
a000aea8:	05820010 	streq	r0, [r2, #16]                               <== NOT EXECUTED
  information->signals_posted  = 0;                                   
a000aeac:	05820014 	streq	r0, [r2, #20]                               <== NOT EXECUTED
  information->signals_pending = 0;                                   
a000aeb0:	05820018 	streq	r0, [r2, #24]                               <== NOT EXECUTED
  information->nest_level      = 0;                                   
a000aeb4:	0582001c 	streq	r0, [r2, #28]                               <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch(); /* cannot reschedule while */           
                              /*   the thread is inconsistent */      
                                                                      
  if ( !_ASR_Is_null_handler( asr_handler ) ) {                       
    asr->mode_set = mode_set;                                         
a000aeb8:	15821010 	strne	r1, [r2, #16]                               <== NOT EXECUTED
    asr->handler = asr_handler;                                       
  }                                                                   
  else                                                                
    _ASR_Initialize( asr );                                           
  _Thread_Enable_dispatch();                                          
a000aebc:	eb0009aa 	bl	a000d56c <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000aec0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000aec4:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0019298 <rtems_signal_send>: rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) {
a0019298:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
a001929c:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_signal_send(                                  
  rtems_id          id,                                               
  rtems_signal_set  signal_set                                        
)                                                                     
{                                                                     
a00192a0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
a00192a4:	03a0000a 	moveq	r0, #10                                     <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
a00192a8:	1a000001 	bne	a00192b4 <rtems_signal_send+0x1c>             <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00192ac:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00192b0:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a00192b4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00192b8:	eb0011b9 	bl	a001d9a4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a00192bc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a00192c0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00192c4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a00192c8:	1afffff7 	bne	a00192ac <rtems_signal_send+0x14>             <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
a00192cc:	e59030f4 	ldr	r3, [r0, #244]	; 0xf4                         <== NOT EXECUTED
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
a00192d0:	e593200c 	ldr	r2, [r3, #12]                                 <== NOT EXECUTED
a00192d4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a00192d8:	0a00001c 	beq	a0019350 <rtems_signal_send+0xb8>             <== NOT EXECUTED
        if ( asr->is_enabled ) {                                      
a00192dc:	e5d32008 	ldrb	r2, [r3, #8]                                 <== NOT EXECUTED
a00192e0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a00192e4:	0a00000f 	beq	a0019328 <rtems_signal_send+0x90>             <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a00192e8:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a00192ec:	e3821080 	orr	r1, r2, #128	; 0x80                           <== NOT EXECUTED
a00192f0:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
    *signal_set |= signals;                                           
a00192f4:	e5931014 	ldr	r1, [r3, #20]                                 <== NOT EXECUTED
a00192f8:	e1814004 	orr	r4, r1, r4                                    <== NOT EXECUTED
a00192fc:	e5834014 	str	r4, [r3, #20]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0019300:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
a0019304:	e59f3050 	ldr	r3, [pc, #80]	; a001935c <rtems_signal_send+0xc4><== NOT EXECUTED
a0019308:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a001930c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0019310:	0a00000b 	beq	a0019344 <rtems_signal_send+0xac>             <== NOT EXECUTED
a0019314:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a0019318:	e1500002 	cmp	r0, r2                                        <== NOT EXECUTED
            _Thread_Dispatch_necessary = true;                        
a001931c:	03a02001 	moveq	r2, #1                                      <== NOT EXECUTED
a0019320:	05c32010 	strbeq	r2, [r3, #16]                              <== NOT EXECUTED
a0019324:	ea000006 	b	a0019344 <rtems_signal_send+0xac>               <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0019328:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a001932c:	e3821080 	orr	r1, r2, #128	; 0x80                           <== NOT EXECUTED
a0019330:	e129f001 	msr	CPSR_fc, r1                                   <== NOT EXECUTED
a0019334:	e5931018 	ldr	r1, [r3, #24]                                 <== NOT EXECUTED
a0019338:	e1814004 	orr	r4, r1, r4                                    <== NOT EXECUTED
a001933c:	e5834018 	str	r4, [r3, #24]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0019340:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
a0019344:	eb00118d 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a0019348:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a001934c:	eaffffd6 	b	a00192ac <rtems_signal_send+0x14>               <== NOT EXECUTED
      }                                                               
      _Thread_Enable_dispatch();                                      
a0019350:	eb00118a 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_NOT_DEFINED;                                       
a0019354:	e3a0000b 	mov	r0, #11                                       <== NOT EXECUTED
a0019358:	eaffffd3 	b	a00192ac <rtems_signal_send+0x14>               <== NOT EXECUTED
                                                                      

a00058c4 <rtems_stack_checker_begin_extension>: Thread_Control *the_thread ) { Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */
a00058c4:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
a00058c8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return;                                                           
                                                                      
  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
                                                                      
  *the_pattern = Stack_check_Pattern;                                 
a00058cc:	1590c0b8 	ldrne	ip, [r0, #184]	; 0xb8                       <== NOT EXECUTED
a00058d0:	159f300c 	ldrne	r3, [pc, #12]	; a00058e4 <rtems_stack_checker_begin_extension+0x20><== NOT EXECUTED
a00058d4:	128cc008 	addne	ip, ip, #8                                  <== NOT EXECUTED
a00058d8:	1893000f 	ldmne	r3, {r0, r1, r2, r3}                        <== NOT EXECUTED
a00058dc:	188c000f 	stmne	ip, {r0, r1, r2, r3}                        <== NOT EXECUTED
a00058e0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0005a08 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
a0005a08:	e92d4830 	push	{r4, r5, fp, lr}                             <== NOT EXECUTED
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
a0005a0c:	e59f4074 	ldr	r4, [pc, #116]	; a0005a88 <rtems_stack_checker_is_blown+0x80><== NOT EXECUTED
                                                                      
/*                                                                    
 *  Check if blown                                                    
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
{                                                                     
a0005a10:	e28db00c 	add	fp, sp, #12                                   <== NOT EXECUTED
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
a0005a14:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
a0005a18:	e59300b8 	ldr	r0, [r3, #184]	; 0xb8                         <== NOT EXECUTED
a0005a1c:	e15b0000 	cmp	fp, r0                                        <== NOT EXECUTED
      return false;                                                   
a0005a20:	33a05000 	movcc	r5, #0                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
a0005a24:	3a000004 	bcc	a0005a3c <rtems_stack_checker_is_blown+0x34>  <== NOT EXECUTED
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
a0005a28:	e59350b4 	ldr	r5, [r3, #180]	; 0xb4                         <== NOT EXECUTED
a0005a2c:	e0805005 	add	r5, r0, r5                                    <== NOT EXECUTED
}                                                                     
                                                                      
/*                                                                    
 *  Check if blown                                                    
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
a0005a30:	e15b0005 	cmp	fp, r5                                        <== NOT EXECUTED
a0005a34:	83a05000 	movhi	r5, #0                                      <== NOT EXECUTED
a0005a38:	93a05001 	movls	r5, #1                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
a0005a3c:	e59f3048 	ldr	r3, [pc, #72]	; a0005a8c <rtems_stack_checker_is_blown+0x84><== NOT EXECUTED
a0005a40:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0005a44:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
 */                                                                   
bool rtems_stack_checker_is_blown( void )                             
{                                                                     
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
a0005a48:	03a01001 	moveq	r1, #1                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
a0005a4c:	0a000005 	beq	a0005a68 <rtems_stack_checker_is_blown+0x60>  <== NOT EXECUTED
    pattern_ok = (!memcmp(                                            
a0005a50:	e59f1038 	ldr	r1, [pc, #56]	; a0005a90 <rtems_stack_checker_is_blown+0x88><== NOT EXECUTED
a0005a54:	e2800008 	add	r0, r0, #8                                    <== NOT EXECUTED
a0005a58:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
a0005a5c:	eb002fad 	bl	a0011918 <memcmp>                              <== NOT EXECUTED
a0005a60:	e2701001 	rsbs	r1, r0, #1                                   <== NOT EXECUTED
a0005a64:	33a01000 	movcc	r1, #0                                      <== NOT EXECUTED
                                                                      
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
a0005a68:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0005a6c:	0a000003 	beq	a0005a80 <rtems_stack_checker_is_blown+0x78>  <== NOT EXECUTED
a0005a70:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0005a74:	0a000001 	beq	a0005a80 <rtems_stack_checker_is_blown+0x78>  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  return false;                                                       
}                                                                     
a0005a78:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0005a7c:	e8bd8830 	pop	{r4, r5, fp, pc}                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
    Stack_check_report_blown_task( _Thread_Executing, pattern_ok );   
a0005a80:	e5940004 	ldr	r0, [r4, #4]                                  <== NOT EXECUTED
a0005a84:	ebffff97 	bl	a00058e8 <Stack_check_report_blown_task>       <== NOT EXECUTED
                                                                      

a0005aec <rtems_stack_checker_report_usage>: } void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
a0005aec:	e59f1004 	ldr	r1, [pc, #4]	; a0005af8 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED
a0005af0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0005af4:	eaffffe6 	b	a0005a94 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
                                                                      

a0005a94 <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
a0005a94:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  if ( !print )                                                       
a0005a98:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
void rtems_stack_checker_report_usage_with_plugin(                    
  void                  *context,                                     
  rtems_printk_plugin_t  print                                        
)                                                                     
{                                                                     
a0005a9c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  if ( !print )                                                       
a0005aa0:	0a00000c 	beq	a0005ad8 <rtems_stack_checker_report_usage_with_plugin+0x44><== NOT EXECUTED
    return;                                                           
                                                                      
  print_context = context;                                            
a0005aa4:	e59f4030 	ldr	r4, [pc, #48]	; a0005adc <rtems_stack_checker_report_usage_with_plugin+0x48><== NOT EXECUTED
  print_handler = print;                                              
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
a0005aa8:	e59f1030 	ldr	r1, [pc, #48]	; a0005ae0 <rtems_stack_checker_report_usage_with_plugin+0x4c><== NOT EXECUTED
)                                                                     
{                                                                     
  if ( !print )                                                       
    return;                                                           
                                                                      
  print_context = context;                                            
a0005aac:	e5840004 	str	r0, [r4, #4]                                  <== NOT EXECUTED
  print_handler = print;                                              
a0005ab0:	e5845000 	str	r5, [r4]                                      <== NOT EXECUTED
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
a0005ab4:	e12fff35 	blx	r5                                            <== NOT EXECUTED
  (*print)( context,                                                  
a0005ab8:	e59f1024 	ldr	r1, [pc, #36]	; a0005ae4 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
a0005abc:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0005ac0:	e12fff35 	blx	r5                                            <== NOT EXECUTED
"    ID      NAME    LOW          HIGH     CURRENT     AVAILABLE     USED\n"
  );                                                                  
                                                                      
  /* iterate over all threads and dump the usage */                   
  rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );   
a0005ac4:	e59f001c 	ldr	r0, [pc, #28]	; a0005ae8 <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
a0005ac8:	eb0014a9 	bl	a000ad74 <rtems_iterate_over_all_threads>      <== NOT EXECUTED
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    /* dump interrupt stack info if any */                            
    Stack_check_Dump_threads_usage((Thread_Control *) -1);            
  #endif                                                              
                                                                      
  print_context = NULL;                                               
a0005acc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0005ad0:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
  print_handler = NULL;                                               
a0005ad4:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
a0005ad8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000599c <rtems_stack_checker_switch_extension>: */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) {
a000599c:	e92d4810 	push	{r4, fp, lr}                                 <== NOT EXECUTED
  Stack_Control *the_stack = &running->Start.Initial_stack;           
  void          *pattern;                                             
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
                                                                      
  pattern = Stack_check_Get_pattern_area(the_stack);                  
a00059a0:	e59030b8 	ldr	r3, [r0, #184]	; 0xb8                         <== NOT EXECUTED
 */                                                                   
void rtems_stack_checker_switch_extension(                            
  Thread_Control *running __attribute__((unused)),                    
  Thread_Control *heir __attribute__((unused))                        
)                                                                     
{                                                                     
a00059a4:	e28db008 	add	fp, sp, #8                                    <== NOT EXECUTED
a00059a8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
a00059ac:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
  Stack_Control *the_stack = &running->Start.Initial_stack;           
  void          *pattern;                                             
  bool           sp_ok;                                               
  bool           pattern_ok = true;                                   
                                                                      
  pattern = Stack_check_Get_pattern_area(the_stack);                  
a00059b0:	e2830008 	add	r0, r3, #8                                    <== NOT EXECUTED
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
a00059b4:	3a000003 	bcc	a00059c8 <rtems_stack_checker_switch_extension+0x2c><== NOT EXECUTED
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
a00059b8:	e59420b4 	ldr	r2, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a00059bc:	e0833002 	add	r3, r3, r2                                    <== NOT EXECUTED
a00059c0:	e15b0003 	cmp	fp, r3                                        <== NOT EXECUTED
a00059c4:	9a000006 	bls	a00059e4 <rtems_stack_checker_switch_extension+0x48><== NOT EXECUTED
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
a00059c8:	e59f1034 	ldr	r1, [pc, #52]	; a0005a04 <rtems_stack_checker_switch_extension+0x68><== NOT EXECUTED
a00059cc:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
a00059d0:	eb002fd0 	bl	a0011918 <memcmp>                              <== NOT EXECUTED
a00059d4:	e2701001 	rsbs	r1, r0, #1                                   <== NOT EXECUTED
a00059d8:	33a01000 	movcc	r1, #0                                      <== NOT EXECUTED
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
    Stack_check_report_blown_task( running, pattern_ok );             
a00059dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00059e0:	ebffffc0 	bl	a00058e8 <Stack_check_report_blown_task>       <== NOT EXECUTED
  /*                                                                  
   *  Check for an out of bounds stack pointer or an overwrite        
   */                                                                 
  sp_ok = Stack_check_Frame_pointer_in_range( the_stack );            
                                                                      
  pattern_ok = (!memcmp( pattern,                                     
a00059e4:	e59f1018 	ldr	r1, [pc, #24]	; a0005a04 <rtems_stack_checker_switch_extension+0x68><== NOT EXECUTED
a00059e8:	e3a02010 	mov	r2, #16                                       <== NOT EXECUTED
a00059ec:	eb002fc9 	bl	a0011918 <memcmp>                              <== NOT EXECUTED
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
a00059f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00059f4:	1a000000 	bne	a00059fc <rtems_stack_checker_switch_extension+0x60><== NOT EXECUTED
a00059f8:	e8bd8810 	pop	{r4, fp, pc}                                  <== NOT EXECUTED
a00059fc:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0005a00:	eafffff5 	b	a00059dc <rtems_stack_checker_switch_extension+0x40><== NOT EXECUTED
                                                                      

a000ae04 <rtems_status_text>: const char *rtems_status_text( rtems_status_code status ) {
a000ae04:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  return rtems_assoc_name_by_local(rtems_status_assoc, status);       
a000ae08:	e59f0000 	ldr	r0, [pc, #0]	; a000ae10 <rtems_status_text+0xc><== NOT EXECUTED
a000ae0c:	ea0022f1 	b	a00139d8 <rtems_assoc_name_by_local>            <== NOT EXECUTED
                                                                      

a000ff9c <rtems_string_to_double>: rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) {
a000ff9c:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a000ffa0:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_string_to_double (                            
  const char *s,                                                      
  double *n,                                                          
  char **endptr                                                       
)                                                                     
{                                                                     
a000ffa4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a000ffa8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000ffac:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a000ffb0:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a000ffb4:	0a000017 	beq	a0010018 <rtems_string_to_double+0x7c>        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a000ffb8:	eb00091b 	bl	a001242c <__errno>                             <== NOT EXECUTED
a000ffbc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ffc0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
a000ffc4:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000ffc8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000ffcc:	e884000c 	stm	r4, {r2, r3}                                  <== NOT EXECUTED
                                                                      
  result = strtod( s, &end );                                         
a000ffd0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000ffd4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ffd8:	eb00148a 	bl	a0015208 <strtod>                              <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a000ffdc:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a000ffe0:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
                                                                      
  if ( endptr )                                                       
a000ffe4:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
a000ffe8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a000ffec:	15883000 	strne	r3, [r8]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a000fff0:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
a000fff4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
a000fff8:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtod( s, &end );                                         
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a000fffc:	0a000005 	beq	a0010018 <rtems_string_to_double+0x7c>        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010000:	eb000909 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010004:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010008:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a001000c:	0a000003 	beq	a0010020 <rtems_string_to_double+0x84>        <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a0010010:	e8840060 	stm	r4, {r5, r6}                                  <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010014:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010018:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001001c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010020:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010024:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010028:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a001002c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010030:	ebffdd84 	bl	a0007648 <__cmpdf2>                            <== NOT EXECUTED
a0010034:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010038:	0a00000e 	beq	a0010078 <rtems_string_to_double+0xdc>        <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
a001003c:	e3e03102 	mvn	r3, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0010040:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010044:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010048:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a001004c:	e2433601 	sub	r3, r3, #1048576	; 0x100000                   <== NOT EXECUTED
a0010050:	ebffdd78 	bl	a0007638 <__gedf2>                             <== NOT EXECUTED
a0010054:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010058:	ca000006 	bgt	a0010078 <rtems_string_to_double+0xdc>        <== NOT EXECUTED
a001005c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0010060:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0010064:	e3e02000 	mvn	r2, #0                                        <== NOT EXECUTED
a0010068:	e3e03601 	mvn	r3, #1048576	; 0x100000                       <== NOT EXECUTED
a001006c:	ebffdd73 	bl	a0007640 <__ledf2>                             <== NOT EXECUTED
a0010070:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010074:	aaffffe5 	bge	a0010010 <rtems_string_to_double+0x74>        <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a0010078:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a001007c:	eaffffe5 	b	a0010018 <rtems_string_to_double+0x7c>          <== NOT EXECUTED
                                                                      

a0010080 <rtems_string_to_float>: rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) {
a0010080:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010084:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_string_to_float (                             
  const char *s,                                                      
  float *n,                                                           
  char **endptr                                                       
)                                                                     
{                                                                     
a0010088:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a001008c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010090:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a0010094:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010098:	0a000015 	beq	a00100f4 <rtems_string_to_float+0x74>         <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a001009c:	eb0008e2 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00100a0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00100a4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
a00100a8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00100ac:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
                                                                      
  result = strtof( s, &end );                                         
a00100b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00100b4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00100b8:	eb001459 	bl	a0015224 <strtof>                              <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a00100bc:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a00100c0:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtof( s, &end );                                         
                                                                      
  if ( endptr )                                                       
a00100c4:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtof( s, &end );                                         
a00100c8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a00100cc:	15863000 	strne	r3, [r6]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a00100d0:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a00100d4:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtof( s, &end );                                         
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a00100d8:	0a000005 	beq	a00100f4 <rtems_string_to_float+0x74>         <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00100dc:	eb0008d2 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00100e0:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00100e4:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a00100e8:	0a000003 	beq	a00100fc <rtems_string_to_float+0x7c>         <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a00100ec:	e5857000 	str	r7, [r5]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a00100f0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00100f4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00100f8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00100fc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010100:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0010104:	ebffdd9a 	bl	a0007774 <__cmpsf2>                            <== NOT EXECUTED
a0010108:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a001010c:	0a00000a 	beq	a001013c <rtems_string_to_float+0xbc>         <== NOT EXECUTED
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
a0010110:	e3e01102 	mvn	r1, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0010114:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0010118:	e2411502 	sub	r1, r1, #8388608	; 0x800000                   <== NOT EXECUTED
a001011c:	ebffdd90 	bl	a0007764 <__gesf2>                             <== NOT EXECUTED
a0010120:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010124:	ca000004 	bgt	a001013c <rtems_string_to_float+0xbc>         <== NOT EXECUTED
a0010128:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a001012c:	e3e01502 	mvn	r1, #8388608	; 0x800000                       <== NOT EXECUTED
a0010130:	ebffdd8d 	bl	a000776c <__lesf2>                             <== NOT EXECUTED
a0010134:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0010138:	aaffffeb 	bge	a00100ec <rtems_string_to_float+0x6c>         <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a001013c:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010140:	eaffffeb 	b	a00100f4 <rtems_string_to_float+0x74>           <== NOT EXECUTED
                                                                      

a0010144 <rtems_string_to_int>: const char *s, int *n, char **endptr, int base ) {
a0010144:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010148:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  int *n,                                                             
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a001014c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0010150:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010154:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a0010158:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a001015c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010160:	0a000015 	beq	a00101bc <rtems_string_to_int+0x78>           <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a0010164:	eb0008b0 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010168:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a001016c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
a0010170:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
a0010174:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
  result = strtol( s, &end, base );                                   
a0010178:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001017c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010180:	eb0014a9 	bl	a001542c <strtol>                              <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a0010184:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a0010188:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
a001018c:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
a0010190:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a0010194:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a0010198:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a001019c:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a00101a0:	0a000005 	beq	a00101bc <rtems_string_to_int+0x78>           <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00101a4:	eb0008a0 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00101a8:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00101ac:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a00101b0:	0a000003 	beq	a00101c4 <rtems_string_to_int+0x80>           <== NOT EXECUTED
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
a00101b4:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a00101b8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00101bc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00101c0:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00101c4:	e3770106 	cmn	r7, #-2147483647	; 0x80000001                 <== NOT EXECUTED
a00101c8:	13570000 	cmpne	r7, #0                                      <== NOT EXECUTED
a00101cc:	0a000001 	beq	a00101d8 <rtems_string_to_int+0x94>           <== NOT EXECUTED
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
a00101d0:	e3570102 	cmp	r7, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a00101d4:	1afffff6 	bne	a00101b4 <rtems_string_to_int+0x70>           <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a00101d8:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a00101dc:	eafffff6 	b	a00101bc <rtems_string_to_int+0x78>             <== NOT EXECUTED
                                                                      

a00102b0 <rtems_string_to_long>: const char *s, long *n, char **endptr, int base ) {
a00102b0:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00102b4:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  long *n,                                                            
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a00102b8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00102bc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00102c0:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a00102c4:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a00102c8:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00102cc:	0a000015 	beq	a0010328 <rtems_string_to_long+0x78>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a00102d0:	eb000855 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00102d4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00102d8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
a00102dc:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
a00102e0:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
  result = strtol( s, &end, base );                                   
a00102e4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00102e8:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00102ec:	eb00144e 	bl	a001542c <strtol>                              <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a00102f0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a00102f4:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
a00102f8:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
a00102fc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a0010300:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a0010304:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a0010308:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a001030c:	0a000005 	beq	a0010328 <rtems_string_to_long+0x78>          <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010310:	eb000845 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010314:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010318:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a001031c:	0a000003 	beq	a0010330 <rtems_string_to_long+0x80>          <== NOT EXECUTED
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a0010320:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010324:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010328:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001032c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010330:	e3770106 	cmn	r7, #-2147483647	; 0x80000001                 <== NOT EXECUTED
a0010334:	13570000 	cmpne	r7, #0                                      <== NOT EXECUTED
a0010338:	0a000001 	beq	a0010344 <rtems_string_to_long+0x94>          <== NOT EXECUTED
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
a001033c:	e3570102 	cmp	r7, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0010340:	1afffff6 	bne	a0010320 <rtems_string_to_long+0x70>          <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a0010344:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a0010348:	eafffff6 	b	a0010328 <rtems_string_to_long+0x78>            <== NOT EXECUTED
                                                                      

a00101e0 <rtems_string_to_long_long>: const char *s, long long *n, char **endptr, int base ) {
a00101e0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00101e4:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  long long *n,                                                       
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a00101e8:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00101ec:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00101f0:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a00101f4:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a00101f8:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00101fc:	0a000018 	beq	a0010264 <rtems_string_to_long_long+0x84>     <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a0010200:	eb000889 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010204:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010208:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
a001020c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0010210:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010214:	e886000c 	stm	r6, {r2, r3}                                  <== NOT EXECUTED
                                                                      
  result = strtoll( s, &end, base );                                  
a0010218:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001021c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0010220:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010224:	eb00148b 	bl	a0015458 <strtoll>                             <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a0010228:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a001022c:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
a0010230:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
a0010234:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a0010238:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a001023c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
a0010240:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
a0010244:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtoll( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a0010248:	0a000005 	beq	a0010264 <rtems_string_to_long_long+0x84>     <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a001024c:	eb000876 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010250:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010254:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a0010258:	0a000003 	beq	a001026c <rtems_string_to_long_long+0x8c>     <== NOT EXECUTED
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a001025c:	e8860180 	stm	r6, {r7, r8}                                  <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010260:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010264:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0010268:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
a001026c:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a0010270:	e3e04102 	mvn	r4, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a0010274:	e0233007 	eor	r3, r3, r7                                    <== NOT EXECUTED
a0010278:	e0244008 	eor	r4, r4, r8                                    <== NOT EXECUTED
a001027c:	e1932004 	orrs	r2, r3, r4                                   <== NOT EXECUTED
a0010280:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0010284:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
a0010288:	e1972008 	orrs	r2, r7, r8                                   <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a001028c:	03833001 	orreq	r3, r3, #1                                  <== NOT EXECUTED
a0010290:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010294:	1a000003 	bne	a00102a8 <rtems_string_to_long_long+0xc8>     <== NOT EXECUTED
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
a0010298:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a001029c:	1affffee 	bne	a001025c <rtems_string_to_long_long+0x7c>     <== NOT EXECUTED
a00102a0:	e3580102 	cmp	r8, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a00102a4:	1affffec 	bne	a001025c <rtems_string_to_long_long+0x7c>     <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;                                    
a00102a8:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a00102ac:	eaffffec 	b	a0010264 <rtems_string_to_long_long+0x84>       <== NOT EXECUTED
                                                                      

a001034c <rtems_string_to_pointer>: const char *s, void **n, char **endptr ) { return STRTOFUNC( s, n, endptr );
a001034c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010350:	ea000080 	b	a0010558 <rtems_string_to_unsigned_long>        <== NOT EXECUTED
                                                                      

a0010354 <rtems_string_to_unsigned_char>: const char *s, unsigned char *n, char **endptr, int base ) {
a0010354:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010358:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  unsigned char *n,                                                   
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a001035c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0010360:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010364:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a0010368:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a001036c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010370:	0a000017 	beq	a00103d4 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a0010374:	eb00082c 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010378:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a001037c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a0010380:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
a0010384:	e5c63000 	strb	r3, [r6]                                     <== NOT EXECUTED
                                                                      
  result = strtoul( s, &end, base );                                  
a0010388:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001038c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010390:	eb001554 	bl	a00158e8 <strtoul>                             <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a0010394:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a0010398:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
a001039c:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a00103a0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a00103a4:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a00103a8:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a00103ac:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a00103b0:	0a000007 	beq	a00103d4 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00103b4:	eb00081c 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00103b8:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00103bc:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a00103c0:	0a000005 	beq	a00103dc <rtems_string_to_unsigned_char+0x88> <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
a00103c4:	e35700ff 	cmp	r7, #255	; 0xff                               <== NOT EXECUTED
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
a00103c8:	95c67000 	strbls	r7, [r6]                                   <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a00103cc:	93a00000 	movls	r0, #0                                      <== NOT EXECUTED
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
a00103d0:	8a000009 	bhi	a00103fc <rtems_string_to_unsigned_char+0xa8> <== NOT EXECUTED
#endif                                                                
                                                                      
  *n = result;                                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a00103d4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00103d8:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
a00103dc:	e2473001 	sub	r3, r7, #1                                    <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00103e0:	e3730003 	cmn	r3, #3                                        <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
a00103e4:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00103e8:	8afffff9 	bhi	a00103d4 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
a00103ec:	e35700ff 	cmp	r7, #255	; 0xff                               <== NOT EXECUTED
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
a00103f0:	95c67000 	strbls	r7, [r6]                                   <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a00103f4:	93a00000 	movls	r0, #0                                      <== NOT EXECUTED
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
#if (UCHAR_MAX < ULONG_MAX)                                           
  if ( result > UCHAR_MAX ) {                                         
a00103f8:	9afffff5 	bls	a00103d4 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
    errno = ERANGE;                                                   
a00103fc:	eb00080a 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010400:	e3a03022 	mov	r3, #34	; 0x22                                <== NOT EXECUTED
a0010404:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
a0010408:	e3a0000a 	mov	r0, #10                                       <== NOT EXECUTED
a001040c:	eafffff0 	b	a00103d4 <rtems_string_to_unsigned_char+0x80>   <== NOT EXECUTED
                                                                      

a0010410 <rtems_string_to_unsigned_int>: const char *s, unsigned int *n, char **endptr, int base ) {
a0010410:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010414:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  unsigned int *n,                                                    
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a0010418:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a001041c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010420:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a0010424:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a0010428:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a001042c:	0a000015 	beq	a0010488 <rtems_string_to_unsigned_int+0x78>  <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a0010430:	eb0007fd 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010434:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010438:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a001043c:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
a0010440:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
  result = strtoul( s, &end, base );                                  
a0010444:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010448:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a001044c:	eb001525 	bl	a00158e8 <strtoul>                             <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a0010450:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a0010454:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
a0010458:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a001045c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a0010460:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a0010464:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a0010468:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a001046c:	0a000005 	beq	a0010488 <rtems_string_to_unsigned_int+0x78>  <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010470:	eb0007ed 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010474:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010478:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a001047c:	0a000003 	beq	a0010490 <rtems_string_to_unsigned_int+0x80>  <== NOT EXECUTED
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
a0010480:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010484:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010488:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001048c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
a0010490:	e2473001 	sub	r3, r7, #1                                    <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010494:	e3730003 	cmn	r3, #3                                        <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
a0010498:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a001049c:	9afffff7 	bls	a0010480 <rtems_string_to_unsigned_int+0x70>  <== NOT EXECUTED
a00104a0:	eafffff8 	b	a0010488 <rtems_string_to_unsigned_int+0x78>    <== NOT EXECUTED
                                                                      

a0010558 <rtems_string_to_unsigned_long>: const char *s, unsigned long *n, char **endptr, int base ) {
a0010558:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a001055c:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  unsigned long *n,                                                   
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a0010560:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0010564:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0010568:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a001056c:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a0010570:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a0010574:	0a000015 	beq	a00105d0 <rtems_string_to_unsigned_long+0x78> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a0010578:	eb0007ab 	bl	a001242c <__errno>                             <== NOT EXECUTED
a001057c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0010580:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a0010584:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
a0010588:	e5863000 	str	r3, [r6]                                      <== NOT EXECUTED
                                                                      
  result = strtoul( s, &end, base );                                  
a001058c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0010590:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0010594:	eb0014d3 	bl	a00158e8 <strtoul>                             <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a0010598:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a001059c:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
a00105a0:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
a00105a4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a00105a8:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a00105ac:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a00105b0:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a00105b4:	0a000005 	beq	a00105d0 <rtems_string_to_unsigned_long+0x78> <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00105b8:	eb00079b 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00105bc:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00105c0:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a00105c4:	0a000003 	beq	a00105d8 <rtems_string_to_unsigned_long+0x80> <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a00105c8:	e5867000 	str	r7, [r6]                                      <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a00105cc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a00105d0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00105d4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
a00105d8:	e2473001 	sub	r3, r7, #1                                    <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00105dc:	e3730003 	cmn	r3, #3                                        <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
a00105e0:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a00105e4:	9afffff7 	bls	a00105c8 <rtems_string_to_unsigned_long+0x70> <== NOT EXECUTED
a00105e8:	eafffff8 	b	a00105d0 <rtems_string_to_unsigned_long+0x78>   <== NOT EXECUTED
                                                                      

a00104a4 <rtems_string_to_unsigned_long_long>: const char *s, unsigned long long *n, char **endptr, int base ) {
a00104a4:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00104a8:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  const char *s,                                                      
  unsigned long long *n,                                              
  char **endptr,                                                      
  int base                                                            
)                                                                     
{                                                                     
a00104ac:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a00104b0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a00104b4:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a00104b8:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
    return RTEMS_INVALID_ADDRESS;                                     
a00104bc:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
a00104c0:	0a000018 	beq	a0010528 <rtems_string_to_unsigned_long_long+0x84><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
a00104c4:	eb0007d8 	bl	a001242c <__errno>                             <== NOT EXECUTED
a00104c8:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00104cc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  *n = 0;                                                             
a00104d0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a00104d4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00104d8:	e886000c 	stm	r6, {r2, r3}                                  <== NOT EXECUTED
                                                                      
  result = strtoull( s, &end, base );                                 
a00104dc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00104e0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a00104e4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00104e8:	eb001509 	bl	a0015914 <strtoull>                            <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
a00104ec:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    *endptr = end;                                                    
a00104f0:	159d3000 	ldrne	r3, [sp]                                    <== NOT EXECUTED
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
                                                                      
  if ( endptr )                                                       
a00104f4:	059d3000 	ldreq	r3, [sp]                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
a00104f8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
a00104fc:	15853000 	strne	r3, [r5]                                    <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
a0010500:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
a0010504:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
a0010508:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  result = strtoull( s, &end, base );                                 
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
a001050c:	0a000005 	beq	a0010528 <rtems_string_to_unsigned_long_long+0x84><== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010510:	eb0007c5 	bl	a001242c <__errno>                             <== NOT EXECUTED
a0010514:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a0010518:	e3530022 	cmp	r3, #34	; 0x22                                <== NOT EXECUTED
a001051c:	0a000003 	beq	a0010530 <rtems_string_to_unsigned_long_long+0x8c><== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
a0010520:	e8860180 	stm	r6, {r7, r8}                                  <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010524:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
}                                                                     
a0010528:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001052c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
a0010530:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a0010534:	e0933007 	adds	r3, r3, r7                                   <== NOT EXECUTED
a0010538:	e3e04000 	mvn	r4, #0                                        <== NOT EXECUTED
a001053c:	e0a44008 	adc	r4, r4, r8                                    <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010540:	e3740001 	cmn	r4, #1                                        <== NOT EXECUTED
a0010544:	1afffff5 	bne	a0010520 <rtems_string_to_unsigned_long_long+0x7c><== NOT EXECUTED
a0010548:	e3730003 	cmn	r3, #3                                        <== NOT EXECUTED
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
a001054c:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
a0010550:	9afffff2 	bls	a0010520 <rtems_string_to_unsigned_long_long+0x7c><== NOT EXECUTED
a0010554:	eafffff3 	b	a0010528 <rtems_string_to_unsigned_long_long+0x84><== NOT EXECUTED
                                                                      

a0005e20 <rtems_tarfs_load>: int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) {
a0005e20:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0005e24:	e24ddf6b 	sub	sp, sp, #428	; 0x1ac                          <== NOT EXECUTED
a0005e28:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a0005e2c:	e1a07002 	mov	r7, r2                                        <== NOT EXECUTED
a0005e30:	e58d0018 	str	r0, [sp, #24]                                 <== NOT EXECUTED
   int                              offset;                           
   unsigned long                    nblocks;                          
   IMFS_jnode_t                    *node;                             
   int                              status;                           
                                                                      
   status = rtems_filesystem_evaluate_path(                           
a0005e34:	eb003eb3 	bl	a0015908 <strlen>                              <== NOT EXECUTED
a0005e38:	e28d2f65 	add	r2, sp, #404	; 0x194                          <== NOT EXECUTED
a0005e3c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0005e40:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a0005e44:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
a0005e48:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0005e4c:	e28d3f65 	add	r3, sp, #404	; 0x194                          <== NOT EXECUTED
a0005e50:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a0005e54:	eb0002be 	bl	a0006954 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
      strlen(mountpoint),                                             
      0,                                                              
      &root_loc,                                                      
      0                                                               
   );                                                                 
   if (status != 0)                                                   
a0005e58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
     return -1;                                                       
a0005e5c:	13e02000 	mvnne	r2, #0                                      <== NOT EXECUTED
      strlen(mountpoint),                                             
      0,                                                              
      &root_loc,                                                      
      0                                                               
   );                                                                 
   if (status != 0)                                                   
a0005e60:	e58d0014 	str	r0, [sp, #20]                                 <== NOT EXECUTED
     return -1;                                                       
a0005e64:	158d2014 	strne	r2, [sp, #20]                               <== NOT EXECUTED
      strlen(mountpoint),                                             
      0,                                                              
      &root_loc,                                                      
      0                                                               
   );                                                                 
   if (status != 0)                                                   
a0005e68:	1a000032 	bne	a0005f38 <rtems_tarfs_load+0x118>             <== NOT EXECUTED
     return -1;                                                       
                                                                      
   if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)    
a0005e6c:	e59d31a0 	ldr	r3, [sp, #416]	; 0x1a0                        <== NOT EXECUTED
a0005e70:	e59f21d4 	ldr	r2, [pc, #468]	; a000604c <rtems_tarfs_load+0x22c><== NOT EXECUTED
a0005e74:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0005e78:	059d8014 	ldreq	r8, [sp, #20]                               <== NOT EXECUTED
a0005e7c:	1a00006b 	bne	a0006030 <rtems_tarfs_load+0x210>             <== NOT EXECUTED
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while (1) {                                                        
    if (offset + 512 > tar_size)                                      
a0005e80:	e2884c02 	add	r4, r8, #512	; 0x200                          <== NOT EXECUTED
     *        should not have this path.                              
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
a0005e84:	e28d3d06 	add	r3, sp, #384	; 0x180                          <== NOT EXECUTED
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while (1) {                                                        
    if (offset + 512 > tar_size)                                      
a0005e88:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
a0005e8c:	e28d5f47 	add	r5, sp, #284	; 0x11c                          <== NOT EXECUTED
     *        should not have this path.                              
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
a0005e90:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while (1) {                                                        
    if (offset + 512 > tar_size)                                      
a0005e94:	8a000027 	bhi	a0005f38 <rtems_tarfs_load+0x118>             <== NOT EXECUTED
      break;                                                          
                                                                      
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
a0005e98:	e0868008 	add	r8, r6, r8                                    <== NOT EXECUTED
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
a0005e9c:	e2880c01 	add	r0, r8, #256	; 0x100                          <== NOT EXECUTED
a0005ea0:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a0005ea4:	e59f11a4 	ldr	r1, [pc, #420]	; a0006050 <rtems_tarfs_load+0x230><== NOT EXECUTED
a0005ea8:	e3a02005 	mov	r2, #5                                        <== NOT EXECUTED
a0005eac:	eb003ead 	bl	a0015968 <strncmp>                             <== NOT EXECUTED
a0005eb0:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
a0005eb4:	1a00001f 	bne	a0005f38 <rtems_tarfs_load+0x118>             <== NOT EXECUTED
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
a0005eb8:	e3a02063 	mov	r2, #99	; 0x63                                <== NOT EXECUTED
a0005ebc:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0005ec0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0005ec4:	eb003f08 	bl	a0015aec <strncpy>                             <== NOT EXECUTED
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
a0005ec8:	e3a01008 	mov	r1, #8                                        <== NOT EXECUTED
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
a0005ecc:	e5cda17f 	strb	sl, [sp, #383]	; 0x17f                       <== NOT EXECUTED
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
a0005ed0:	e2880064 	add	r0, r8, #100	; 0x64                           <== NOT EXECUTED
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
a0005ed4:	e5d8b09c 	ldrb	fp, [r8, #156]	; 0x9c                        <== NOT EXECUTED
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
a0005ed8:	eb002010 	bl	a000df20 <_rtems_octal2ulong>                  <== NOT EXECUTED
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
a0005edc:	e3a0100c 	mov	r1, #12                                       <== NOT EXECUTED
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
a0005ee0:	e58d0010 	str	r0, [sp, #16]                                 <== NOT EXECUTED
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
a0005ee4:	e288007c 	add	r0, r8, #124	; 0x7c                           <== NOT EXECUTED
a0005ee8:	eb00200c 	bl	a000df20 <_rtems_octal2ulong>                  <== NOT EXECUTED
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
a0005eec:	e3a01008 	mov	r1, #8                                        <== NOT EXECUTED
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
    filename[MAX_NAME_FIELD_SIZE] = '\0';                             
                                                                      
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
a0005ef0:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
a0005ef4:	e2880094 	add	r0, r8, #148	; 0x94                           <== NOT EXECUTED
a0005ef8:	eb002008 	bl	a000df20 <_rtems_octal2ulong>                  <== NOT EXECUTED
a0005efc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
                                                                      
    if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)            
a0005f00:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a0005f04:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a0005f08:	eb002111 	bl	a000e354 <_rtems_tar_header_checksum>          <== NOT EXECUTED
a0005f0c:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0005f10:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0005f14:	1a000007 	bne	a0005f38 <rtems_tarfs_load+0x118>             <== NOT EXECUTED
     * Generate an IMFS node depending on the file type.              
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
a0005f18:	e35b0035 	cmp	fp, #53	; 0x35                                <== NOT EXECUTED
a0005f1c:	0a00001a 	beq	a0005f8c <rtems_tarfs_load+0x16c>             <== NOT EXECUTED
     *        IMFS_create_node was ONLY passed a NULL when we created the
     *        root node.  We added a new IMFS_create_root_node() so this
     *        path no longer existed.  The result was simpler code which
     *        should not have this path.                              
     */                                                               
    else if (linkflag == REGTYPE) {                                   
a0005f20:	e35b0030 	cmp	fp, #48	; 0x30                                <== NOT EXECUTED
a0005f24:	0a000006 	beq	a0005f44 <rtems_tarfs_load+0x124>             <== NOT EXECUTED
      0                                                               
   );                                                                 
   if (status != 0)                                                   
     return -1;                                                       
                                                                      
   if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)    
a0005f28:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while (1) {                                                        
    if (offset + 512 > tar_size)                                      
a0005f2c:	e2884c02 	add	r4, r8, #512	; 0x200                          <== NOT EXECUTED
a0005f30:	e1540007 	cmp	r4, r7                                        <== NOT EXECUTED
a0005f34:	9affffd7 	bls	a0005e98 <rtems_tarfs_load+0x78>              <== NOT EXECUTED
      nblocks = (((file_size) + 511) & ~511) / 512;                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
  return status;                                                      
}                                                                     
a0005f38:	e59d0014 	ldr	r0, [sp, #20]                                 <== NOT EXECUTED
a0005f3c:	e28ddf6b 	add	sp, sp, #428	; 0x1ac                          <== NOT EXECUTED
a0005f40:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
     *        should not have this path.                              
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
a0005f44:	e59dc008 	ldr	ip, [sp, #8]                                  <== NOT EXECUTED
a0005f48:	e59de004 	ldr	lr, [sp, #4]                                  <== NOT EXECUTED
a0005f4c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0005f50:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0005f54:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
a0005f58:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0005f5c:	e28d1d06 	add	r1, sp, #384	; 0x180                          <== NOT EXECUTED
a0005f60:	e28d2f6a 	add	r2, sp, #424	; 0x1a8                          <== NOT EXECUTED
     *        should not have this path.                              
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
a0005f64:	e58ec000 	str	ip, [lr]                                      <== NOT EXECUTED
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
a0005f68:	eb002311 	bl	a000ebb4 <IMFS_evaluate_for_make>              <== NOT EXECUTED
a0005f6c:	e2508000 	subs	r8, r0, #0                                   <== NOT EXECUTED
a0005f70:	0a00001c 	beq	a0005fe8 <rtems_tarfs_load+0x1c8>             <== NOT EXECUTED
        );                                                            
        node->info.linearfile.size   = file_size;                     
        node->info.linearfile.direct = &tar_image[offset];            
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
a0005f74:	e2899f7f 	add	r9, r9, #508	; 0x1fc                          <== NOT EXECUTED
a0005f78:	e2899003 	add	r9, r9, #3                                    <== NOT EXECUTED
a0005f7c:	e1a094a9 	lsr	r9, r9, #9                                    <== NOT EXECUTED
      offset += 512 * nblocks;                                        
a0005f80:	e0844489 	add	r4, r4, r9, lsl #9                            <== NOT EXECUTED
      0                                                               
   );                                                                 
   if (status != 0)                                                   
     return -1;                                                       
                                                                      
   if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)    
a0005f84:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
a0005f88:	eaffffe7 	b	a0005f2c <rtems_tarfs_load+0x10c>               <== NOT EXECUTED
     * - For directories, just create directories as usual.  IMFS     
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
a0005f8c:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
a0005f90:	e28d001c 	add	r0, sp, #28                                   <== NOT EXECUTED
a0005f94:	eb003c97 	bl	a00151f8 <strcpy>                              <== NOT EXECUTED
      if (full_filename[strlen(full_filename)-1] != '/')              
a0005f98:	e28d001c 	add	r0, sp, #28                                   <== NOT EXECUTED
a0005f9c:	eb003e59 	bl	a0015908 <strlen>                              <== NOT EXECUTED
a0005fa0:	e28def6b 	add	lr, sp, #428	; 0x1ac                          <== NOT EXECUTED
a0005fa4:	e08e3000 	add	r3, lr, r0                                    <== NOT EXECUTED
a0005fa8:	e5533191 	ldrb	r3, [r3, #-401]	; 0x191                      <== NOT EXECUTED
      0                                                               
   );                                                                 
   if (status != 0)                                                   
     return -1;                                                       
                                                                      
   if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)    
a0005fac:	e1a08004 	mov	r8, r4                                        <== NOT EXECUTED
     *   will take care of the rest.                                  
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
      if (full_filename[strlen(full_filename)-1] != '/')              
a0005fb0:	e353002f 	cmp	r3, #47	; 0x2f                                <== NOT EXECUTED
        strcat(full_filename, "/");                                   
a0005fb4:	128d101c 	addne	r1, sp, #28                                 <== NOT EXECUTED
a0005fb8:	10813000 	addne	r3, r1, r0                                  <== NOT EXECUTED
a0005fbc:	13a0202f 	movne	r2, #47	; 0x2f                              <== NOT EXECUTED
a0005fc0:	17c12000 	strbne	r2, [r1, r0]                               <== NOT EXECUTED
a0005fc4:	15c3a001 	strbne	sl, [r3, #1]                               <== NOT EXECUTED
      strcat(full_filename, filename);                                
a0005fc8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0005fcc:	e28d001c 	add	r0, sp, #28                                   <== NOT EXECUTED
a0005fd0:	eb003bd1 	bl	a0014f1c <strcat>                              <== NOT EXECUTED
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
a0005fd4:	e3a01f7f 	mov	r1, #508	; 0x1fc                              <== NOT EXECUTED
a0005fd8:	e28d001c 	add	r0, sp, #28                                   <== NOT EXECUTED
a0005fdc:	e2811003 	add	r1, r1, #3                                    <== NOT EXECUTED
a0005fe0:	eb0004d5 	bl	a000733c <mkdir>                               <== NOT EXECUTED
a0005fe4:	eaffffd0 	b	a0005f2c <rtems_tarfs_load+0x10c>               <== NOT EXECUTED
      loc = root_loc;                                                 
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
        node = IMFS_create_node(                                      
          &loc,                                                       
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
a0005fe8:	e59d1010 	ldr	r1, [sp, #16]                                 <== NOT EXECUTED
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
        node = IMFS_create_node(                                      
a0005fec:	e28d0d06 	add	r0, sp, #384	; 0x180                          <== NOT EXECUTED
a0005ff0:	e59d21a8 	ldr	r2, [sp, #424]	; 0x1a8                        <== NOT EXECUTED
          &loc,                                                       
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
a0005ff4:	e1a03b81 	lsl	r3, r1, #23                                   <== NOT EXECUTED
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
        node = IMFS_create_node(                                      
a0005ff8:	e3a01006 	mov	r1, #6                                        <== NOT EXECUTED
          &loc,                                                       
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
a0005ffc:	e1a03ba3 	lsr	r3, r3, #23                                   <== NOT EXECUTED
    else if (linkflag == REGTYPE) {                                   
      const char  *name;                                              
                                                                      
      loc = root_loc;                                                 
      if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {       
        node = IMFS_create_node(                                      
a0006000:	e3833902 	orr	r3, r3, #32768	; 0x8000                       <== NOT EXECUTED
a0006004:	e58d8000 	str	r8, [sp]                                      <== NOT EXECUTED
a0006008:	eb002144 	bl	a000e520 <IMFS_create_node>                    <== NOT EXECUTED
          &loc,                                                       
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
a000600c:	e5809050 	str	r9, [r0, #80]	; 0x50                          <== NOT EXECUTED
        node->info.linearfile.direct = &tar_image[offset];            
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
a0006010:	e2899f7f 	add	r9, r9, #508	; 0x1fc                          <== NOT EXECUTED
a0006014:	e2899003 	add	r9, r9, #3                                    <== NOT EXECUTED
a0006018:	e1a094a9 	lsr	r9, r9, #9                                    <== NOT EXECUTED
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
        node->info.linearfile.direct = &tar_image[offset];            
a000601c:	e0863004 	add	r3, r6, r4                                    <== NOT EXECUTED
          &loc,                                                       
          IMFS_LINEAR_FILE, (char *)name,                             
          (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,      
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
a0006020:	e5808054 	str	r8, [r0, #84]	; 0x54                          <== NOT EXECUTED
        node->info.linearfile.direct = &tar_image[offset];            
a0006024:	e5803058 	str	r3, [r0, #88]	; 0x58                          <== NOT EXECUTED
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
      offset += 512 * nblocks;                                        
a0006028:	e0844489 	add	r4, r4, r9, lsl #9                            <== NOT EXECUTED
a000602c:	eaffffd4 	b	a0005f84 <rtems_tarfs_load+0x164>               <== NOT EXECUTED
      0                                                               
   );                                                                 
   if (status != 0)                                                   
     return -1;                                                       
                                                                      
   if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)    
a0006030:	e59f201c 	ldr	r2, [pc, #28]	; a0006054 <rtems_tarfs_load+0x234><== NOT EXECUTED
a0006034:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0006038:	01a08000 	moveq	r8, r0                                      <== NOT EXECUTED
a000603c:	0affff8f 	beq	a0005e80 <rtems_tarfs_load+0x60>              <== NOT EXECUTED
     return -1;                                                       
a0006040:	e3e03000 	mvn	r3, #0                                        <== NOT EXECUTED
a0006044:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
a0006048:	eaffffba 	b	a0005f38 <rtems_tarfs_load+0x118>               <== NOT EXECUTED
                                                                      

a0009c38 <rtems_task_create>: size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, rtems_id *id ) {
a0009c38:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
a0009c3c:	e24dd01c 	sub	sp, sp, #28                                   
a0009c40:	e59d9044 	ldr	r9, [sp, #68]	; 0x44                          
a0009c44:	e1a04000 	mov	r4, r0                                        
a0009c48:	e1a0a001 	mov	sl, r1                                        
  Priority_Control         core_priority;                             
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
                                                                      
  if ( !id )                                                          
a0009c4c:	e3590000 	cmp	r9, #0                                        
  size_t               stack_size,                                    
  rtems_mode           initial_modes,                                 
  rtems_attribute      attribute_set,                                 
  rtems_id            *id                                             
)                                                                     
{                                                                     
a0009c50:	e1a06002 	mov	r6, r2                                        
a0009c54:	e1a05003 	mov	r5, r3                                        
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
                                                                      
  if ( !id )                                                          
   return RTEMS_INVALID_ADDRESS;                                      
a0009c58:	03a00009 	moveq	r0, #9                                      
  Priority_Control         core_priority;                             
  RTEMS_API_Control       *api;                                       
  ASR_Information         *asr;                                       
                                                                      
                                                                      
  if ( !id )                                                          
a0009c5c:	0a000031 	beq	a0009d28 <rtems_task_create+0xf0>             
   return RTEMS_INVALID_ADDRESS;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0009c60:	e3540000 	cmp	r4, #0                                        
    return RTEMS_INVALID_NAME;                                        
a0009c64:	03a00003 	moveq	r0, #3                                      
                                                                      
                                                                      
  if ( !id )                                                          
   return RTEMS_INVALID_ADDRESS;                                      
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a0009c68:	0a00002e 	beq	a0009d28 <rtems_task_create+0xf0>             
                                                                      
  /*                                                                  
   *  Validate the RTEMS API priority and convert it to the core priority range.
   */                                                                 
                                                                      
  if ( !_Attributes_Is_system_task( the_attribute_set ) ) {           
a0009c6c:	e59d3040 	ldr	r3, [sp, #64]	; 0x40                          
a0009c70:	e3130902 	tst	r3, #32768	; 0x8000                           
a0009c74:	1a000005 	bne	a0009c90 <rtems_task_create+0x58>             
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
a0009c78:	e3510000 	cmp	r1, #0                                        
a0009c7c:	0a00002b 	beq	a0009d30 <rtems_task_create+0xf8>             
            ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );             
a0009c80:	e59f30e0 	ldr	r3, [pc, #224]	; a0009d68 <rtems_task_create+0x130>
a0009c84:	e5d33000 	ldrb	r3, [r3]                                     
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
a0009c88:	e1510003 	cmp	r1, r3                                        
a0009c8c:	8a000027 	bhi	a0009d30 <rtems_task_create+0xf8>             
   */                                                                 
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
a0009c90:	e59fb0d4 	ldr	fp, [pc, #212]	; a0009d6c <rtems_task_create+0x134>
a0009c94:	e59b0000 	ldr	r0, [fp]                                      
a0009c98:	eb0001aa 	bl	a000a348 <_API_Mutex_Lock>                     
 *  This function allocates a task control block from                 
 *  the inactive chain of free task control blocks.                   
 */                                                                   
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )    
{                                                                     
  return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
a0009c9c:	e59f00cc 	ldr	r0, [pc, #204]	; a0009d70 <rtems_task_create+0x138>
a0009ca0:	eb000444 	bl	a000adb8 <_Objects_Allocate>                   
   *         the event of an error.                                   
   */                                                                 
                                                                      
  the_thread = _RTEMS_tasks_Allocate();                               
                                                                      
  if ( !the_thread ) {                                                
a0009ca4:	e2507000 	subs	r7, r0, #0                                   
a0009ca8:	0a00002a 	beq	a0009d58 <rtems_task_create+0x120>            
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
                                                                      
  status = _Thread_Initialize(                                        
a0009cac:	e3150c01 	tst	r5, #256	; 0x100                              
a0009cb0:	13a01000 	movne	r1, #0                                      
a0009cb4:	03a01001 	moveq	r1, #1                                      
a0009cb8:	e3150c02 	tst	r5, #512	; 0x200                              
 */                                                                   
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(              
  rtems_attribute attribute_set                                       
)                                                                     
{                                                                     
   return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;    
a0009cbc:	e3a08000 	mov	r8, #0                                        
a0009cc0:	03a02000 	moveq	r2, #0                                      
a0009cc4:	13a02001 	movne	r2, #1                                      
 */                                                                   
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (           
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  return ( mode_set & RTEMS_INTERRUPT_MASK );                         
a0009cc8:	e2053080 	and	r3, r5, #128	; 0x80                           
a0009ccc:	e58d1008 	str	r1, [sp, #8]                                  
a0009cd0:	e58d200c 	str	r2, [sp, #12]                                 
a0009cd4:	e58d3014 	str	r3, [sp, #20]                                 
a0009cd8:	e59f0090 	ldr	r0, [pc, #144]	; a0009d70 <rtems_task_create+0x138>
a0009cdc:	e1a01007 	mov	r1, r7                                        
a0009ce0:	e1a02008 	mov	r2, r8                                        
a0009ce4:	e1a03006 	mov	r3, r6                                        
a0009ce8:	e88d0500 	stm	sp, {r8, sl}                                  
a0009cec:	e58d8010 	str	r8, [sp, #16]                                 
a0009cf0:	e58d4018 	str	r4, [sp, #24]                                 
a0009cf4:	eb0008e3 	bl	a000c088 <_Thread_Initialize>                  
    NULL,        /* no budget algorithm callout */                    
    _Modes_Get_interrupt_level(initial_modes),                        
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  if ( !status ) {                                                    
a0009cf8:	e1500008 	cmp	r0, r8                                        
a0009cfc:	0a00000d 	beq	a0009d38 <rtems_task_create+0x100>            
    _RTEMS_Unlock_allocator();                                        
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
  asr = &api->Signal;                                                 
a0009d00:	e59720f4 	ldr	r2, [r7, #244]	; 0xf4                         
                                                                      
  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
                                                                      
  *id = the_thread->Object.id;                                        
a0009d04:	e5973008 	ldr	r3, [r7, #8]                                  
 *    id               - thread id                                    
 *    RTEMS_SUCCESSFUL - if successful                                
 *    error code       - if unsuccessful                              
 */                                                                   
                                                                      
rtems_status_code rtems_task_create(                                  
a0009d08:	e3150b01 	tst	r5, #1024	; 0x400                             
a0009d0c:	13a01000 	movne	r1, #0                                      
a0009d10:	03a01001 	moveq	r1, #1                                      
    );                                                                
                                                                      
   }                                                                  
#endif                                                                
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0009d14:	e59b0000 	ldr	r0, [fp]                                      
 *    id               - thread id                                    
 *    RTEMS_SUCCESSFUL - if successful                                
 *    error code       - if unsuccessful                              
 */                                                                   
                                                                      
rtems_status_code rtems_task_create(                                  
a0009d18:	e5c21008 	strb	r1, [r2, #8]                                 
  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];               
  asr = &api->Signal;                                                 
                                                                      
  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
                                                                      
  *id = the_thread->Object.id;                                        
a0009d1c:	e5893000 	str	r3, [r9]                                      
    );                                                                
                                                                      
   }                                                                  
#endif                                                                
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0009d20:	eb0001a4 	bl	a000a3b8 <_API_Mutex_Unlock>                   
  return RTEMS_SUCCESSFUL;                                            
a0009d24:	e1a00008 	mov	r0, r8                                        
}                                                                     
a0009d28:	e28dd01c 	add	sp, sp, #28                                   
a0009d2c:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
   *  Validate the RTEMS API priority and convert it to the core priority range.
   */                                                                 
                                                                      
  if ( !_Attributes_Is_system_task( the_attribute_set ) ) {           
    if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )        
      return RTEMS_INVALID_PRIORITY;                                  
a0009d30:	e3a00013 	mov	r0, #19                                       <== NOT EXECUTED
a0009d34:	eafffffb 	b	a0009d28 <rtems_task_create+0xf0>               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (                         
  Thread_Control *the_task                                            
)                                                                     
{                                                                     
  _Objects_Free(                                                      
a0009d38:	e5970008 	ldr	r0, [r7, #8]                                  <== NOT EXECUTED
a0009d3c:	eb000515 	bl	a000b198 <_Objects_Get_information_id>         <== NOT EXECUTED
a0009d40:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0009d44:	eb0004f5 	bl	a000b120 <_Objects_Free>                       <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)                                    
    if ( is_global )                                                  
      _Objects_MP_Free_global_object( the_global_object );            
#endif                                                                
    _RTEMS_tasks_Free( the_thread );                                  
    _RTEMS_Unlock_allocator();                                        
a0009d48:	e59b0000 	ldr	r0, [fp]                                      <== NOT EXECUTED
a0009d4c:	eb000199 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
a0009d50:	e3a0000d 	mov	r0, #13                                       <== NOT EXECUTED
a0009d54:	eafffff3 	b	a0009d28 <rtems_task_create+0xf0>               <== NOT EXECUTED
   */                                                                 
                                                                      
  the_thread = _RTEMS_tasks_Allocate();                               
                                                                      
  if ( !the_thread ) {                                                
    _RTEMS_Unlock_allocator();                                        
a0009d58:	e59b0000 	ldr	r0, [fp]                                      <== NOT EXECUTED
a0009d5c:	eb000195 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a0009d60:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a0009d64:	eaffffef 	b	a0009d28 <rtems_task_create+0xf0>               <== NOT EXECUTED
                                                                      

a0009d74 <rtems_task_delete>: */ rtems_status_code rtems_task_delete( rtems_id id ) {
a0009d74:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  Objects_Information     *the_information;                           
                                                                      
  _RTEMS_Lock_allocator();                                            
a0009d78:	e59f4070 	ldr	r4, [pc, #112]	; a0009df0 <rtems_task_delete+0x7c><== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_task_delete(                                  
  rtems_id id                                                         
)                                                                     
{                                                                     
a0009d7c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0009d80:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  Objects_Information     *the_information;                           
                                                                      
  _RTEMS_Lock_allocator();                                            
a0009d84:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0009d88:	eb00016e 	bl	a000a348 <_API_Mutex_Lock>                     <== NOT EXECUTED
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a0009d8c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009d90:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0009d94:	eb000896 	bl	a000bff4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a0009d98:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
  Objects_Locations        location;                                  
  Objects_Information     *the_information;                           
                                                                      
  _RTEMS_Lock_allocator();                                            
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a0009d9c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  switch ( location ) {                                               
a0009da0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0009da4:	1a00000d 	bne	a0009de0 <rtems_task_delete+0x6c>             <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      the_information = _Objects_Get_information_id( the_thread->Object.id );
a0009da8:	e5900008 	ldr	r0, [r0, #8]                                  <== NOT EXECUTED
a0009dac:	eb0004f9 	bl	a000b198 <_Objects_Get_information_id>         <== NOT EXECUTED
            0                                /* Not used */           
          );                                                          
        }                                                             
      #endif                                                          
                                                                      
      _Thread_Close( the_information, the_thread );                   
a0009db0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0009db4:	eb0007ba 	bl	a000bca4 <_Thread_Close>                       <== NOT EXECUTED
a0009db8:	e5960008 	ldr	r0, [r6, #8]                                  <== NOT EXECUTED
a0009dbc:	eb0004f5 	bl	a000b198 <_Objects_Get_information_id>         <== NOT EXECUTED
a0009dc0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0009dc4:	eb0004d5 	bl	a000b120 <_Objects_Free>                       <== NOT EXECUTED
                                                                      
      _RTEMS_tasks_Free( the_thread );                                
                                                                      
      _RTEMS_Unlock_allocator();                                      
a0009dc8:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0009dcc:	eb000179 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0009dd0:	eb00087e 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0009dd4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
      break;                                                          
  }                                                                   
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009dd8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0009ddc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  _RTEMS_Unlock_allocator();                                          
a0009de0:	e5940000 	ldr	r0, [r4]                                      <== NOT EXECUTED
a0009de4:	eb000173 	bl	a000a3b8 <_API_Mutex_Unlock>                   <== NOT EXECUTED
  return RTEMS_INVALID_ID;                                            
a0009de8:	e3a00004 	mov	r0, #4                                        <== NOT EXECUTED
a0009dec:	eafffff9 	b	a0009dd8 <rtems_task_delete+0x64>               <== NOT EXECUTED
                                                                      

a000c048 <rtems_task_get_note>: rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) {
a000c048:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000c04c:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c050:	e59f10a4 	ldr	r1, [pc, #164]	; a000c0fc <rtems_task_get_note+0xb4><== NOT EXECUTED
rtems_status_code rtems_task_get_note(                                
  rtems_id    id,                                                     
  uint32_t    notepad,                                                
  uint32_t   *note                                                    
)                                                                     
{                                                                     
a000c054:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a000c058:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c05c:	e5d11004 	ldrb	r1, [r1, #4]                                 <== NOT EXECUTED
a000c060:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_CONFIGURED;                                      
a000c064:	03a00016 	moveq	r0, #22                                     <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c068:	0a000019 	beq	a000c0d4 <rtems_task_get_note+0x8c>           <== NOT EXECUTED
    return RTEMS_NOT_CONFIGURED;                                      
                                                                      
  if ( !note )                                                        
a000c06c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a000c070:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
    return RTEMS_NOT_CONFIGURED;                                      
                                                                      
  if ( !note )                                                        
a000c074:	0a000016 	beq	a000c0d4 <rtems_task_get_note+0x8c>           <== NOT EXECUTED
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
a000c078:	e354000f 	cmp	r4, #15                                       <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
a000c07c:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
a000c080:	8a000013 	bhi	a000c0d4 <rtems_task_get_note+0x8c>           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c084:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c088:	0a000013 	beq	a000c0dc <rtems_task_get_note+0x94>           <== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
a000c08c:	e59f106c 	ldr	r1, [pc, #108]	; a000c100 <rtems_task_get_note+0xb8><== NOT EXECUTED
a000c090:	e5911004 	ldr	r1, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c094:	e591c008 	ldr	ip, [r1, #8]                                  <== NOT EXECUTED
a000c098:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a000c09c:	0a000010 	beq	a000c0e4 <rtems_task_get_note+0x9c>           <== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      *note = api->Notepads[ notepad ];                               
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000c0a0:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a000c0a4:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000c0a8:	eb00095a 	bl	a000e618 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000c0ac:	e89d0024 	ldm	sp, {r2, r5}                                  <== NOT EXECUTED
a000c0b0:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000c0b4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
      *note = api->Notepads[ notepad ];                               
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000c0b8:	1a000005 	bne	a000c0d4 <rtems_task_get_note+0x8c>           <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
      *note = api->Notepads[ notepad ];                               
a000c0bc:	e59030f4 	ldr	r3, [r0, #244]	; 0xf4                         <== NOT EXECUTED
a000c0c0:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
a000c0c4:	e7933104 	ldr	r3, [r3, r4, lsl #2]                          <== NOT EXECUTED
a000c0c8:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a000c0cc:	eb000948 	bl	a000e5f4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c0d0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000c0d4:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000c0d8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c0dc:	e59f301c 	ldr	r3, [pc, #28]	; a000c100 <rtems_task_get_note+0xb8><== NOT EXECUTED
a000c0e0:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      *note = api->Notepads[ notepad ];                               
a000c0e4:	e59130f4 	ldr	r3, [r1, #244]	; 0xf4                         <== NOT EXECUTED
a000c0e8:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c0ec:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      *note = api->Notepads[ notepad ];                               
a000c0f0:	e7933104 	ldr	r3, [r3, r4, lsl #2]                          <== NOT EXECUTED
a000c0f4:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c0f8:	eafffff5 	b	a000c0d4 <rtems_task_get_note+0x8c>             <== NOT EXECUTED
                                                                      

a0009df4 <rtems_task_ident>: rtems_id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id )
a0009df4:	e2523000 	subs	r3, r2, #0                                   <== NOT EXECUTED
rtems_status_code rtems_task_ident(                                   
  rtems_name    name,                                                 
  uint32_t      node,                                                 
  rtems_id     *id                                                    
)                                                                     
{                                                                     
a0009df8:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0009dfc:	e1a0c000 	mov	ip, r0                                        <== NOT EXECUTED
a0009e00:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  if ( !id )                                                          
a0009e04:	0a00000c 	beq	a0009e3c <rtems_task_ident+0x48>              <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( name == OBJECTS_ID_OF_SELF ) {                                 
a0009e08:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0009e0c:	1a000004 	bne	a0009e24 <rtems_task_ident+0x30>              <== NOT EXECUTED
    *id = _Thread_Executing->Object.id;                               
a0009e10:	e59f202c 	ldr	r2, [pc, #44]	; a0009e44 <rtems_task_ident+0x50><== NOT EXECUTED
a0009e14:	e5922004 	ldr	r2, [r2, #4]                                  <== NOT EXECUTED
a0009e18:	e5922008 	ldr	r2, [r2, #8]                                  <== NOT EXECUTED
a0009e1c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;                                          
a0009e20:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
   }                                                                  
                                                                      
  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
a0009e24:	e59f001c 	ldr	r0, [pc, #28]	; a0009e48 <rtems_task_ident+0x54><== NOT EXECUTED
a0009e28:	e1a0100c 	mov	r1, ip                                        <== NOT EXECUTED
a0009e2c:	eb000569 	bl	a000b3d8 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a0009e30:	e59f3014 	ldr	r3, [pc, #20]	; a0009e4c <rtems_task_ident+0x58><== NOT EXECUTED
a0009e34:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a0009e38:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
)                                                                     
{                                                                     
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
a0009e3c:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
   }                                                                  
                                                                      
  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
}                                                                     
a0009e40:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00196c4 <rtems_task_is_suspended>: */ rtems_status_code rtems_task_is_suspended( rtems_id id ) {
a00196c4:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a00196c8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a00196cc:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a00196d0:	eb0010b3 	bl	a001d9a4 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a00196d4:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a00196d8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a00196dc:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a00196e0:	1a000004 	bne	a00196f8 <rtems_task_is_suspended+0x34>       <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (                      
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_SUSPENDED);                            
a00196e4:	e5904010 	ldr	r4, [r0, #16]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_States_Is_suspended( the_thread->current_state ) ) {     
a00196e8:	e2144002 	ands	r4, r4, #2                                   <== NOT EXECUTED
a00196ec:	0a000003 	beq	a0019700 <rtems_task_is_suspended+0x3c>       <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a00196f0:	eb0010a2 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_ALREADY_SUSPENDED;                                 
a00196f4:	e3a0000f 	mov	r0, #15                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a00196f8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a00196fc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_States_Is_suspended( the_thread->current_state ) ) {     
        _Thread_Enable_dispatch();                                    
a0019700:	eb00109e 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a0019704:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0019708:	eafffffa 	b	a00196f8 <rtems_task_is_suspended+0x34>         <== NOT EXECUTED
                                                                      

a0010c54 <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
a0010c54:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  ASR_Information    *asr;                                            
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
a0010c58:	e2525000 	subs	r5, r2, #0                                   <== NOT EXECUTED
rtems_status_code rtems_task_mode(                                    
  rtems_mode  mode_set,                                               
  rtems_mode  mask,                                                   
  rtems_mode *previous_mode_set                                       
)                                                                     
{                                                                     
a0010c5c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0010c60:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  ASR_Information    *asr;                                            
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
a0010c64:	0a000053 	beq	a0010db8 <rtems_task_mode+0x164>              <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
a0010c68:	e59f9158 	ldr	r9, [pc, #344]	; a0010dc8 <rtems_task_mode+0x174><== NOT EXECUTED
a0010c6c:	e5997004 	ldr	r7, [r9, #4]                                  <== NOT EXECUTED
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
a0010c70:	e59780f4 	ldr	r8, [r7, #244]	; 0xf4                         <== NOT EXECUTED
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
a0010c74:	e5d7a074 	ldrb	sl, [r7, #116]	; 0x74                        <== NOT EXECUTED
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
a0010c78:	e597307c 	ldr	r3, [r7, #124]	; 0x7c                         <== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
a0010c7c:	e5d8b008 	ldrb	fp, [r8, #8]                                 <== NOT EXECUTED
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
a0010c80:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
a0010c84:	03a0ac01 	moveq	sl, #256	; 0x100                            <== NOT EXECUTED
a0010c88:	13a0a000 	movne	sl, #0                                      <== NOT EXECUTED
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
a0010c8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
a0010c90:	138aac02 	orrne	sl, sl, #512	; 0x200                        <== NOT EXECUTED
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
a0010c94:	e35b0000 	cmp	fp, #0                                        <== NOT EXECUTED
a0010c98:	03a0bb01 	moveq	fp, #1024	; 0x400                           <== NOT EXECUTED
a0010c9c:	13a0b000 	movne	fp, #0                                      <== NOT EXECUTED
  old_mode |= _ISR_Get_level();                                       
a0010ca0:	ebfff21c 	bl	a000d518 <_CPU_ISR_Get_level>                  <== NOT EXECUTED
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
a0010ca4:	e18bb000 	orr	fp, fp, r0                                    <== NOT EXECUTED
  old_mode |= _ISR_Get_level();                                       
a0010ca8:	e18ba00a 	orr	sl, fp, sl                                    <== NOT EXECUTED
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
a0010cac:	e3160c01 	tst	r6, #256	; 0x100                              <== NOT EXECUTED
    old_mode |= RTEMS_TIMESLICE;                                      
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
  old_mode |= _ISR_Get_level();                                       
                                                                      
  *previous_mode_set = old_mode;                                      
a0010cb0:	e585a000 	str	sl, [r5]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
a0010cb4:	0a000003 	beq	a0010cc8 <rtems_task_mode+0x74>               <== NOT EXECUTED
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
a0010cb8:	e3140c01 	tst	r4, #256	; 0x100                              <== NOT EXECUTED
a0010cbc:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0010cc0:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
a0010cc4:	e5c73074 	strb	r3, [r7, #116]	; 0x74                        <== NOT EXECUTED
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
a0010cc8:	e3160c02 	tst	r6, #512	; 0x200                              <== NOT EXECUTED
a0010ccc:	1a00001c 	bne	a0010d44 <rtems_task_mode+0xf0>               <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
a0010cd0:	e3160080 	tst	r6, #128	; 0x80                               <== NOT EXECUTED
a0010cd4:	1a000023 	bne	a0010d68 <rtems_task_mode+0x114>              <== NOT EXECUTED
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
a0010cd8:	e2166b01 	ands	r6, r6, #1024	; 0x400                        <== NOT EXECUTED
a0010cdc:	0a000012 	beq	a0010d2c <rtems_task_mode+0xd8>               <== NOT EXECUTED
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
a0010ce0:	e5d82008 	ldrb	r2, [r8, #8]                                 <== NOT EXECUTED
 *  Output:                                                           
 *    *previous_mode_set - previous mode set                          
 *     always return RTEMS_SUCCESSFUL;                                
 */                                                                   
                                                                      
rtems_status_code rtems_task_mode(                                    
a0010ce4:	e3140b01 	tst	r4, #1024	; 0x400                             <== NOT EXECUTED
a0010ce8:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0010cec:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
a0010cf0:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
a0010cf4:	03a06000 	moveq	r6, #0                                      <== NOT EXECUTED
                                                                      
  if ( mask & RTEMS_ASR_MASK ) {                                      
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
a0010cf8:	0a00000b 	beq	a0010d2c <rtems_task_mode+0xd8>               <== NOT EXECUTED
      asr->is_enabled = is_asr_enabled;                               
a0010cfc:	e5c83008 	strb	r3, [r8, #8]                                 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0010d00:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0010d04:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0010d08:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
a0010d0c:	e5981018 	ldr	r1, [r8, #24]                                 <== NOT EXECUTED
    information->signals_pending = information->signals_posted;       
a0010d10:	e5982014 	ldr	r2, [r8, #20]                                 <== NOT EXECUTED
    information->signals_posted  = _signals;                          
a0010d14:	e5881014 	str	r1, [r8, #20]                                 <== NOT EXECUTED
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
    information->signals_pending = information->signals_posted;       
a0010d18:	e5882018 	str	r2, [r8, #24]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0010d1c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
a0010d20:	e5986014 	ldr	r6, [r8, #20]                                 <== NOT EXECUTED
a0010d24:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  This is specific to the RTEMS API                               
   */                                                                 
  is_asr_enabled = false;                                             
  needs_asr_dispatching = false;                                      
a0010d28:	13a06001 	movne	r6, #1                                      <== NOT EXECUTED
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
a0010d2c:	e59f3098 	ldr	r3, [pc, #152]	; a0010dcc <rtems_task_mode+0x178><== NOT EXECUTED
a0010d30:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0010d34:	e3530003 	cmp	r3, #3                                        <== NOT EXECUTED
a0010d38:	0a00000d 	beq	a0010d74 <rtems_task_mode+0x120>              <== NOT EXECUTED
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010d3c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010d40:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
a0010d44:	e2143c02 	ands	r3, r4, #512	; 0x200                         <== NOT EXECUTED
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
a0010d48:	13a03001 	movne	r3, #1                                      <== NOT EXECUTED
a0010d4c:	1587307c 	strne	r3, [r7, #124]	; 0x7c                       <== NOT EXECUTED
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
a0010d50:	159f3078 	ldrne	r3, [pc, #120]	; a0010dd0 <rtems_task_mode+0x17c><== NOT EXECUTED
    } else                                                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 
a0010d54:	0587307c 	streq	r3, [r7, #124]	; 0x7c                       <== NOT EXECUTED
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
    if ( _Modes_Is_timeslice(mode_set) ) {                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
a0010d58:	15933000 	ldrne	r3, [r3]                                    <== NOT EXECUTED
a0010d5c:	15873078 	strne	r3, [r7, #120]	; 0x78                       <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
a0010d60:	e3160080 	tst	r6, #128	; 0x80                               <== NOT EXECUTED
a0010d64:	0affffdb 	beq	a0010cd8 <rtems_task_mode+0x84>               <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (                
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );           
a0010d68:	e2040080 	and	r0, r4, #128	; 0x80                           <== NOT EXECUTED
a0010d6c:	ebfff1e4 	bl	a000d504 <_CPU_ISR_Set_level>                  <== NOT EXECUTED
a0010d70:	eaffffd8 	b	a0010cd8 <rtems_task_mode+0x84>                 <== NOT EXECUTED
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
                                                                      
  if ( are_signals_pending ||                                         
a0010d74:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
  bool are_signals_pending                                            
)                                                                     
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
a0010d78:	e5993004 	ldr	r3, [r9, #4]                                  <== NOT EXECUTED
                                                                      
  if ( are_signals_pending ||                                         
a0010d7c:	1a000008 	bne	a0010da4 <rtems_task_mode+0x150>              <== NOT EXECUTED
a0010d80:	e59f2040 	ldr	r2, [pc, #64]	; a0010dc8 <rtems_task_mode+0x174><== NOT EXECUTED
a0010d84:	e5922008 	ldr	r2, [r2, #8]                                  <== NOT EXECUTED
a0010d88:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0010d8c:	0a00000b 	beq	a0010dc0 <rtems_task_mode+0x16c>              <== NOT EXECUTED
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
a0010d90:	e5d33074 	ldrb	r3, [r3, #116]	; 0x74                        <== NOT EXECUTED
a0010d94:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0010d98:	1a000001 	bne	a0010da4 <rtems_task_mode+0x150>              <== NOT EXECUTED
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010d9c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
}                                                                     
a0010da0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    _Thread_Dispatch_necessary = true;                                
a0010da4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0010da8:	e5c93010 	strb	r3, [r9, #16]                                <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
a0010dac:	ebffec31 	bl	a000be78 <_Thread_Dispatch>                    <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010db0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0010db4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  bool                is_asr_enabled = false;                         
  bool                needs_asr_dispatching = false;                  
  rtems_mode          old_mode;                                       
                                                                      
  if ( !previous_mode_set )                                           
    return RTEMS_INVALID_ADDRESS;                                     
a0010db8:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a0010dbc:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
a0010dc0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0010dc4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      

a000ab58 <rtems_task_restart>: rtems_status_code rtems_task_restart( rtems_id id, uint32_t argument ) {
a000ab58:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000ab5c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000ab60:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000ab64:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ab68:	eb000867 	bl	a000cd0c <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000ab6c:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a000ab70:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000ab74:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000ab78:	1a000006 	bne	a000ab98 <rtems_task_restart+0x40>            <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {          
a000ab7c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000ab80:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a000ab84:	eb000a69 	bl	a000d530 <_Thread_Restart>                     <== NOT EXECUTED
a000ab88:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ab8c:	1a000003 	bne	a000aba0 <rtems_task_restart+0x48>            <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a000ab90:	eb000854 	bl	a000cce8 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INCORRECT_STATE;                                   
a000ab94:	e3a0000e 	mov	r0, #14                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000ab98:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000ab9c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {          
        _Thread_Enable_dispatch();                                    
a000aba0:	eb000850 	bl	a000cce8 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a000aba4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000aba8:	eafffffa 	b	a000ab98 <rtems_task_restart+0x40>              <== NOT EXECUTED
                                                                      

a000d26c <rtems_task_resume>: */ rtems_status_code rtems_task_resume( rtems_id id ) {
a000d26c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000d270:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000d274:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000d278:	eb00085f 	bl	a000f3fc <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000d27c:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000d280:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  switch ( location ) {                                               
a000d284:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000d288:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000d28c:	1a000004 	bne	a000d2a4 <rtems_task_resume+0x38>             <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (                      
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_SUSPENDED);                            
a000d290:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _States_Is_suspended( the_thread->current_state ) ) {      
a000d294:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a000d298:	1a000003 	bne	a000d2ac <rtems_task_resume+0x40>             <== NOT EXECUTED
        _Thread_Resume( the_thread );                                 
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a000d29c:	eb00084d 	bl	a000f3d8 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INCORRECT_STATE;                                   
a000d2a0:	e3a0000e 	mov	r0, #14                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000d2a4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000d2a8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _States_Is_suspended( the_thread->current_state ) ) {      
        _Thread_Resume( the_thread );                                 
a000d2ac:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a000d2b0:	eb00076a 	bl	a000f060 <_Thread_Clear_state>                 <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a000d2b4:	eb000847 	bl	a000f3d8 <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a000d2b8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d2bc:	eafffff8 	b	a000d2a4 <rtems_task_resume+0x38>               <== NOT EXECUTED
                                                                      

a0012d64 <rtems_task_self>: #include <rtems/system.h> #include <rtems/rtems/tasks.h> rtems_id rtems_task_self(void) { return _Thread_Executing->Object.id;
a0012d64:	e59f3008 	ldr	r3, [pc, #8]	; a0012d74 <rtems_task_self+0x10><== NOT EXECUTED
a0012d68:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
}                                                                     
a0012d6c:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a0012d70:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000c1fc <rtems_task_set_note>: rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) {
a000c1fc:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000c200:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c204:	e59f1090 	ldr	r1, [pc, #144]	; a000c29c <rtems_task_set_note+0xa0><== NOT EXECUTED
rtems_status_code rtems_task_set_note(                                
  rtems_id id,                                                        
  uint32_t notepad,                                                   
  uint32_t note                                                       
)                                                                     
{                                                                     
a000c208:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a000c20c:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c210:	e5d11004 	ldrb	r1, [r1, #4]                                 <== NOT EXECUTED
a000c214:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_CONFIGURED;                                      
a000c218:	03a00016 	moveq	r0, #22                                     <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
  RTEMS_API_Control       *api;                                       
                                                                      
  if ( !rtems_configuration_get_notepads_enabled() )                  
a000c21c:	0a000015 	beq	a000c278 <rtems_task_set_note+0x7c>           <== NOT EXECUTED
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
a000c220:	e354000f 	cmp	r4, #15                                       <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
a000c224:	83a0000a 	movhi	r0, #10                                     <== NOT EXECUTED
  /*                                                                  
   *  NOTE:  There is no check for < RTEMS_NOTEPAD_FIRST because that would
   *         be checking an unsigned number for being negative.       
   */                                                                 
                                                                      
  if ( notepad > RTEMS_NOTEPAD_LAST )                                 
a000c228:	8a000012 	bhi	a000c278 <rtems_task_set_note+0x7c>           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c22c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000c230:	0a000012 	beq	a000c280 <rtems_task_set_note+0x84>           <== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
a000c234:	e59f1064 	ldr	r1, [pc, #100]	; a000c2a0 <rtems_task_set_note+0xa4><== NOT EXECUTED
a000c238:	e5911004 	ldr	r1, [r1, #4]                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c23c:	e591c008 	ldr	ip, [r1, #8]                                  <== NOT EXECUTED
a000c240:	e153000c 	cmp	r3, ip                                        <== NOT EXECUTED
a000c244:	0a00000f 	beq	a000c288 <rtems_task_set_note+0x8c>           <== NOT EXECUTED
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      api->Notepads[ notepad ] = note;                                
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000c248:	e28d1004 	add	r1, sp, #4                                    <== NOT EXECUTED
a000c24c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000c250:	eb0008f0 	bl	a000e618 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000c254:	e89d0024 	ldm	sp, {r2, r5}                                  <== NOT EXECUTED
a000c258:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000c25c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
      api->Notepads[ notepad ] = note;                                
      return RTEMS_SUCCESSFUL;                                        
  }                                                                   
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000c260:	1a000004 	bne	a000c278 <rtems_task_set_note+0x7c>           <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
      api->Notepads[ notepad ] = note;                                
a000c264:	e59030f4 	ldr	r3, [r0, #244]	; 0xf4                         <== NOT EXECUTED
a000c268:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
a000c26c:	e7832104 	str	r2, [r3, r4, lsl #2]                          <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a000c270:	eb0008df 	bl	a000e5f4 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c274:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000c278:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000c27c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Optimize the most likely case to avoid the Thread_Dispatch.     
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
a000c280:	e59f3018 	ldr	r3, [pc, #24]	; a000c2a0 <rtems_task_set_note+0xa4><== NOT EXECUTED
a000c284:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      api->Notepads[ notepad ] = note;                                
a000c288:	e59130f4 	ldr	r3, [r1, #244]	; 0xf4                         <== NOT EXECUTED
a000c28c:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c290:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||            
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];    
      api->Notepads[ notepad ] = note;                                
a000c294:	e7832104 	str	r2, [r3, r4, lsl #2]                          <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000c298:	eafffff6 	b	a000c278 <rtems_task_set_note+0x7c>             <== NOT EXECUTED
                                                                      

a000e430 <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
a000e430:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
a000e434:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_task_set_priority(                            
  rtems_id             id,                                            
  rtems_task_priority  new_priority,                                  
  rtems_task_priority *old_priority                                   
)                                                                     
{                                                                     
a000e438:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000e43c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
a000e440:	0a000004 	beq	a000e458 <rtems_task_set_priority+0x28>       <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
            ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );             
a000e444:	e59f3078 	ldr	r3, [pc, #120]	; a000e4c4 <rtems_task_set_priority+0x94><== NOT EXECUTED
a000e448:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
a000e44c:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
a000e450:	83a00013 	movhi	r0, #19                                     <== NOT EXECUTED
a000e454:	8a000018 	bhi	a000e4bc <rtems_task_set_priority+0x8c>       <== NOT EXECUTED
                                                                      
  if ( !old_priority )                                                
a000e458:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a000e45c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
a000e460:	0a000015 	beq	a000e4bc <rtems_task_set_priority+0x8c>       <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000e464:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000e468:	eb0008db 	bl	a00107dc <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000e46c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000e470:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000e474:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !old_priority )                                                
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000e478:	1a00000f 	bne	a000e4bc <rtems_task_set_priority+0x8c>       <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
a000e47c:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
a000e480:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
a000e484:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
a000e488:	0a000009 	beq	a000e4b4 <rtems_task_set_priority+0x84>       <== NOT EXECUTED
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
a000e48c:	e590301c 	ldr	r3, [r0, #28]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
        the_thread->real_priority = new_priority;                     
a000e490:	e5804018 	str	r4, [r0, #24]                                 <== NOT EXECUTED
        if ( the_thread->resource_count == 0 ||                       
a000e494:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000e498:	0a000002 	beq	a000e4a8 <rtems_task_set_priority+0x78>       <== NOT EXECUTED
a000e49c:	e5903014 	ldr	r3, [r0, #20]                                 <== NOT EXECUTED
a000e4a0:	e1540003 	cmp	r4, r3                                        <== NOT EXECUTED
a000e4a4:	2a000002 	bcs	a000e4b4 <rtems_task_set_priority+0x84>       <== NOT EXECUTED
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
a000e4a8:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000e4ac:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000e4b0:	eb0007a0 	bl	a0010338 <_Thread_Change_priority>             <== NOT EXECUTED
      }                                                               
      _Thread_Enable_dispatch();                                      
a000e4b4:	eb0008bf 	bl	a00107b8 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000e4b8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000e4bc:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000e4c0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0009ee0 <rtems_task_start>: rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) {
a0009ee0:	e92d4070 	push	{r4, r5, r6, lr}                             
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( entry_point == NULL )                                          
a0009ee4:	e2515000 	subs	r5, r1, #0                                   
rtems_status_code rtems_task_start(                                   
  rtems_id         	id,                                               
  rtems_task_entry 	entry_point,                                      
  rtems_task_argument	argument                                        
)                                                                     
{                                                                     
a0009ee8:	e24dd008 	sub	sp, sp, #8                                    
a0009eec:	e1a06002 	mov	r6, r2                                        
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( entry_point == NULL )                                          
    return RTEMS_INVALID_ADDRESS;                                     
a0009ef0:	03a00009 	moveq	r0, #9                                      
)                                                                     
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( entry_point == NULL )                                          
a0009ef4:	0a00000e 	beq	a0009f34 <rtems_task_start+0x54>              
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a0009ef8:	e28d1004 	add	r1, sp, #4                                    
a0009efc:	eb00083c 	bl	a000bff4 <_Thread_Get>                         
  switch ( location ) {                                               
a0009f00:	e59d4004 	ldr	r4, [sp, #4]                                  
a0009f04:	e3540000 	cmp	r4, #0                                        
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0009f08:	13a00004 	movne	r0, #4                                      
                                                                      
  if ( entry_point == NULL )                                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a0009f0c:	1a000008 	bne	a0009f34 <rtems_task_start+0x54>              
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Thread_Start(                                             
a0009f10:	e1a01004 	mov	r1, r4                                        
a0009f14:	e1a02005 	mov	r2, r5                                        
a0009f18:	e1a03004 	mov	r3, r4                                        
a0009f1c:	e58d6000 	str	r6, [sp]                                      
a0009f20:	eb000a9b 	bl	a000c994 <_Thread_Start>                       
a0009f24:	e3500000 	cmp	r0, #0                                        
a0009f28:	1a000003 	bne	a0009f3c <rtems_task_start+0x5c>              
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a0009f2c:	eb000827 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INCORRECT_STATE;                                   
a0009f30:	e3a0000e 	mov	r0, #14                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0009f34:	e28dd008 	add	sp, sp, #8                                    
a0009f38:	e8bd8070 	pop	{r4, r5, r6, pc}                              
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Thread_Start(                                             
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();                                    
a0009f3c:	eb000823 	bl	a000bfd0 <_Thread_Enable_dispatch>             
        return RTEMS_SUCCESSFUL;                                      
a0009f40:	e1a00004 	mov	r0, r4                                        
a0009f44:	eafffffa 	b	a0009f34 <rtems_task_start+0x54>                
                                                                      

a000d520 <rtems_task_suspend>: */ rtems_status_code rtems_task_suspend( rtems_id id ) {
a000d520:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000d524:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000d528:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000d52c:	eb00082b 	bl	a000f5e0 <_Thread_Get>                         <== NOT EXECUTED
  switch ( location ) {                                               
a000d530:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
a000d534:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
  switch ( location ) {                                               
a000d538:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000d53c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
a000d540:	1a000004 	bne	a000d558 <rtems_task_suspend+0x38>            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (                      
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_SUSPENDED);                            
a000d544:	e5924010 	ldr	r4, [r2, #16]                                 <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_States_Is_suspended( the_thread->current_state ) ) {     
a000d548:	e2144002 	ands	r4, r4, #2                                   <== NOT EXECUTED
a000d54c:	0a000003 	beq	a000d560 <rtems_task_suspend+0x40>            <== NOT EXECUTED
        _Thread_Suspend( the_thread );                                
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
a000d550:	eb000819 	bl	a000f5bc <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_ALREADY_SUSPENDED;                                 
a000d554:	e3a0000f 	mov	r0, #15                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000d558:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000d55c:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
  the_thread = _Thread_Get( id, &location );                          
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_States_Is_suspended( the_thread->current_state ) ) {     
        _Thread_Suspend( the_thread );                                
a000d560:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a000d564:	eb000a2d 	bl	a000fe20 <_Thread_Set_state>                   <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
a000d568:	eb000813 	bl	a000f5bc <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_SUCCESSFUL;                                      
a000d56c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000d570:	eafffff8 	b	a000d558 <rtems_task_suspend+0x38>              <== NOT EXECUTED
                                                                      

a000ad10 <rtems_task_variable_add>: rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) {
a000ad10:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *new;                                   
                                                                      
  if ( !ptr )                                                         
a000ad14:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_task_variable_add(                            
  rtems_id tid,                                                       
  void **ptr,                                                         
  void (*dtor)(void *)                                                
)                                                                     
{                                                                     
a000ad18:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000ad1c:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *new;                                   
                                                                      
  if ( !ptr )                                                         
    return RTEMS_INVALID_ADDRESS;                                     
a000ad20:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *new;                                   
                                                                      
  if ( !ptr )                                                         
a000ad24:	0a000016 	beq	a000ad84 <rtems_task_variable_add+0x74>       <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
a000ad28:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ad2c:	eb000887 	bl	a000cf50 <_Thread_Get>                         <== NOT EXECUTED
  switch (location) {                                                 
a000ad30:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
  rtems_task_variable_t *tvp, *new;                                   
                                                                      
  if ( !ptr )                                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
a000ad34:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  switch (location) {                                                 
a000ad38:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
a000ad3c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !ptr )                                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
a000ad40:	1a00000f 	bne	a000ad84 <rtems_task_variable_add+0x74>       <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is already in this task's list.  
       */                                                             
      tvp = the_thread->task_variables;                               
a000ad44:	e5963100 	ldr	r3, [r6, #256]	; 0x100                        <== NOT EXECUTED
      while (tvp) {                                                   
a000ad48:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ad4c:	1a000011 	bne	a000ad98 <rtems_task_variable_add+0x88>       <== NOT EXECUTED
                                                                      
      /*                                                              
       *  Now allocate memory for this task variable.                 
       */                                                             
      new = (rtems_task_variable_t *)                                 
         _Workspace_Allocate(sizeof(rtems_task_variable_t));          
a000ad50:	e3a00014 	mov	r0, #20                                       <== NOT EXECUTED
a000ad54:	eb000cca 	bl	a000e084 <_Workspace_Allocate>                 <== NOT EXECUTED
      if (new == NULL) {                                              
a000ad58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000ad5c:	0a000014 	beq	a000adb4 <rtems_task_variable_add+0xa4>       <== NOT EXECUTED
        _Thread_Enable_dispatch();                                    
        return RTEMS_NO_MEMORY;                                       
      }                                                               
      new->gval = *ptr;                                               
a000ad60:	e5942000 	ldr	r2, [r4]                                      <== NOT EXECUTED
      new->ptr = ptr;                                                 
      new->dtor = dtor;                                               
                                                                      
      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
a000ad64:	e5963100 	ldr	r3, [r6, #256]	; 0x100                        <== NOT EXECUTED
      if (new == NULL) {                                              
        _Thread_Enable_dispatch();                                    
        return RTEMS_NO_MEMORY;                                       
      }                                                               
      new->gval = *ptr;                                               
      new->ptr = ptr;                                                 
a000ad68:	e5804004 	str	r4, [r0, #4]                                  <== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));          
      if (new == NULL) {                                              
        _Thread_Enable_dispatch();                                    
        return RTEMS_NO_MEMORY;                                       
      }                                                               
      new->gval = *ptr;                                               
a000ad6c:	e5802008 	str	r2, [r0, #8]                                  <== NOT EXECUTED
      new->ptr = ptr;                                                 
      new->dtor = dtor;                                               
a000ad70:	e5805010 	str	r5, [r0, #16]                                 <== NOT EXECUTED
                                                                      
      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
a000ad74:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
      the_thread->task_variables = new;                               
a000ad78:	e5860100 	str	r0, [r6, #256]	; 0x100                        <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a000ad7c:	eb00086a 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000ad80:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000ad84:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000ad88:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
        if (tvp->ptr == ptr) {                                        
          tvp->dtor = dtor;                                           
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
a000ad8c:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is already in this task's list.  
       */                                                             
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
a000ad90:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ad94:	0affffed 	beq	a000ad50 <rtems_task_variable_add+0x40>       <== NOT EXECUTED
        if (tvp->ptr == ptr) {                                        
a000ad98:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a000ad9c:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000ada0:	1afffff9 	bne	a000ad8c <rtems_task_variable_add+0x7c>       <== NOT EXECUTED
          tvp->dtor = dtor;                                           
a000ada4:	e5835010 	str	r5, [r3, #16]                                 <== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
a000ada8:	eb00085f 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
a000adac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000adb0:	eafffff3 	b	a000ad84 <rtems_task_variable_add+0x74>         <== NOT EXECUTED
       *  Now allocate memory for this task variable.                 
       */                                                             
      new = (rtems_task_variable_t *)                                 
         _Workspace_Allocate(sizeof(rtems_task_variable_t));          
      if (new == NULL) {                                              
        _Thread_Enable_dispatch();                                    
a000adb4:	eb00085c 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
        return RTEMS_NO_MEMORY;                                       
a000adb8:	e3a0001a 	mov	r0, #26                                       <== NOT EXECUTED
a000adbc:	eafffff0 	b	a000ad84 <rtems_task_variable_add+0x74>         <== NOT EXECUTED
                                                                      

a000adc0 <rtems_task_variable_delete>: rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) {
a000adc0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
a000adc4:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_task_variable_delete(                         
  rtems_id  tid,                                                      
  void    **ptr                                                       
)                                                                     
{                                                                     
a000adc8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
    return RTEMS_INVALID_ADDRESS;                                     
a000adcc:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
{                                                                     
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
a000add0:	0a000015 	beq	a000ae2c <rtems_task_variable_delete+0x6c>    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
a000add4:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000add8:	eb00085c 	bl	a000cf50 <_Thread_Get>                         <== NOT EXECUTED
  switch (location) {                                                 
a000addc:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000ade0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000ade4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
a000ade8:	1a00000f 	bne	a000ae2c <rtems_task_variable_delete+0x6c>    <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
a000adec:	e5903100 	ldr	r3, [r0, #256]	; 0x100                        <== NOT EXECUTED
      while (tvp) {                                                   
a000adf0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000adf4:	0a00000a 	beq	a000ae24 <rtems_task_variable_delete+0x64>    <== NOT EXECUTED
        if (tvp->ptr == ptr) {                                        
a000adf8:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a000adfc:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000ae00:	1a000004 	bne	a000ae18 <rtems_task_variable_delete+0x58>    <== NOT EXECUTED
a000ae04:	ea000010 	b	a000ae4c <rtems_task_variable_delete+0x8c>      <== NOT EXECUTED
a000ae08:	e5912004 	ldr	r2, [r1, #4]                                  <== NOT EXECUTED
a000ae0c:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000ae10:	0a000007 	beq	a000ae34 <rtems_task_variable_delete+0x74>    <== NOT EXECUTED
a000ae14:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
a000ae18:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
a000ae1c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000ae20:	1afffff8 	bne	a000ae08 <rtems_task_variable_delete+0x48>    <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
a000ae24:	eb000840 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INVALID_ADDRESS;                                   
a000ae28:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000ae2c:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000ae30:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
a000ae34:	e5912000 	ldr	r2, [r1]                                      <== NOT EXECUTED
a000ae38:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
                                                                      
          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );  
a000ae3c:	eb000028 	bl	a000aee4 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
a000ae40:	eb000839 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
a000ae44:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000ae48:	eafffff7 	b	a000ae2c <rtems_task_variable_delete+0x6c>      <== NOT EXECUTED
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
a000ae4c:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000ae50:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a000ae54:	e5802100 	str	r2, [r0, #256]	; 0x100                        <== NOT EXECUTED
a000ae58:	eafffff7 	b	a000ae3c <rtems_task_variable_delete+0x7c>      <== NOT EXECUTED
                                                                      

a000ae5c <rtems_task_variable_get>: rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) {
a000ae5c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
a000ae60:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(                            
  rtems_id tid,                                                       
  void **ptr,                                                         
  void **result                                                       
)                                                                     
{                                                                     
a000ae64:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000ae68:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
a000ae6c:	0a000017 	beq	a000aed0 <rtems_task_variable_get+0x74>       <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
a000ae70:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000ae74:	0a000015 	beq	a000aed0 <rtems_task_variable_get+0x74>       <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
a000ae78:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a000ae7c:	eb000833 	bl	a000cf50 <_Thread_Get>                         <== NOT EXECUTED
  switch (location) {                                                 
a000ae80:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000ae84:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
a000ae88:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !result )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
  switch (location) {                                                 
a000ae8c:	1a00000d 	bne	a000aec8 <rtems_task_variable_get+0x6c>       <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
a000ae90:	e5903100 	ldr	r3, [r0, #256]	; 0x100                        <== NOT EXECUTED
      while (tvp) {                                                   
a000ae94:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000ae98:	1a000003 	bne	a000aeac <rtems_task_variable_get+0x50>       <== NOT EXECUTED
a000ae9c:	ea00000d 	b	a000aed8 <rtems_task_variable_get+0x7c>         <== NOT EXECUTED
	   */                                                                
          *result = tvp->tval;                                        
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
a000aea0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      /*                                                              
       *  Figure out if the variable is in this task's list.          
       */                                                             
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
a000aea4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000aea8:	0a00000a 	beq	a000aed8 <rtems_task_variable_get+0x7c>       <== NOT EXECUTED
        if (tvp->ptr == ptr) {                                        
a000aeac:	e5932004 	ldr	r2, [r3, #4]                                  <== NOT EXECUTED
a000aeb0:	e1520004 	cmp	r2, r4                                        <== NOT EXECUTED
a000aeb4:	1afffff9 	bne	a000aea0 <rtems_task_variable_get+0x44>       <== NOT EXECUTED
	  /*                                                                 
	   * Should this return the current (i.e not the                     
	   * saved) value if `tid' is the current task?                      
	   */                                                                
          *result = tvp->tval;                                        
a000aeb8:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a000aebc:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
a000aec0:	eb000819 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
a000aec4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000aec8:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000aecc:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  if ( !ptr )                                                         
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
    return RTEMS_INVALID_ADDRESS;                                     
a000aed0:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000aed4:	eafffffb 	b	a000aec8 <rtems_task_variable_get+0x6c>         <== NOT EXECUTED
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
a000aed8:	eb000813 	bl	a000cf2c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_INVALID_ADDRESS;                                   
a000aedc:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000aee0:	eafffff8 	b	a000aec8 <rtems_task_variable_get+0x6c>         <== NOT EXECUTED
                                                                      

a0009f48 <rtems_task_wake_after>:
a0009f48:	e59f307c 	ldr	r3, [pc, #124]	; a0009fcc <rtems_task_wake_after+0x84><== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_task_wake_after(                              
  rtems_interval ticks                                                
)                                                                     
{                                                                     
a0009f4c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0009f50:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a0009f54:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0009f58:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0009f5c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
  _Thread_Disable_dispatch();                                         
    if ( ticks == 0 ) {                                               
a0009f60:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0009f64:	0a000012 	beq	a0009fb4 <rtems_task_wake_after+0x6c>         <== NOT EXECUTED
      _Scheduler_Yield();                                             
    } else {                                                          
      _Thread_Set_state( _Thread_Executing, STATES_DELAYING );        
a0009f68:	e59f5060 	ldr	r5, [pc, #96]	; a0009fd0 <rtems_task_wake_after+0x88><== NOT EXECUTED
a0009f6c:	e3a01008 	mov	r1, #8                                        <== NOT EXECUTED
a0009f70:	e5950004 	ldr	r0, [r5, #4]                                  <== NOT EXECUTED
a0009f74:	eb000a2e 	bl	a000c834 <_Thread_Set_state>                   <== NOT EXECUTED
      _Watchdog_Initialize(                                           
        &_Thread_Executing->Timer,                                    
a0009f78:	e5951004 	ldr	r1, [r5, #4]                                  <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a0009f7c:	e59f0050 	ldr	r0, [pc, #80]	; a0009fd4 <rtems_task_wake_after+0x8c><== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a0009f80:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  _Thread_Disable_dispatch();                                         
    if ( ticks == 0 ) {                                               
      _Scheduler_Yield();                                             
    } else {                                                          
      _Thread_Set_state( _Thread_Executing, STATES_DELAYING );        
      _Watchdog_Initialize(                                           
a0009f84:	e5912008 	ldr	r2, [r1, #8]                                  <== NOT EXECUTED
a0009f88:	e5813050 	str	r3, [r1, #80]	; 0x50                          <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
a0009f8c:	e581306c 	str	r3, [r1, #108]	; 0x6c                         <== NOT EXECUTED
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
a0009f90:	e5812068 	str	r2, [r1, #104]	; 0x68                         <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a0009f94:	e5810064 	str	r0, [r1, #100]	; 0x64                         <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a0009f98:	e5814054 	str	r4, [r1, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a0009f9c:	e59f0034 	ldr	r0, [pc, #52]	; a0009fd8 <rtems_task_wake_after+0x90><== NOT EXECUTED
a0009fa0:	e2811048 	add	r1, r1, #72	; 0x48                            <== NOT EXECUTED
a0009fa4:	eb000b83 	bl	a000cdb8 <_Watchdog_Insert>                    <== NOT EXECUTED
        _Thread_Executing->Object.id,                                 
        NULL                                                          
      );                                                              
      _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );     
    }                                                                 
  _Thread_Enable_dispatch();                                          
a0009fa8:	eb000808 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009fac:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0009fb0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
 *  always operates on the scheduler that 'owns' the currently executing
 *  thread.                                                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )                    
{                                                                     
  _Scheduler.Operations.yield();                                      
a0009fb4:	e59f3020 	ldr	r3, [pc, #32]	; a0009fdc <rtems_task_wake_after+0x94><== NOT EXECUTED
a0009fb8:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a0009fbc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
        _Thread_Executing->Object.id,                                 
        NULL                                                          
      );                                                              
      _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );     
    }                                                                 
  _Thread_Enable_dispatch();                                          
a0009fc0:	eb000802 	bl	a000bfd0 <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0009fc4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0009fc8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000b040 <rtems_task_wake_when>: rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set )
a000b040:	e59f30c8 	ldr	r3, [pc, #200]	; a000b110 <rtems_task_wake_when+0xd0><== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_task_wake_when(                               
  rtems_time_of_day *time_buffer                                      
)                                                                     
{                                                                     
a000b044:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
  Watchdog_Interval   seconds;                                        
                                                                      
  if ( !_TOD_Is_set )                                                 
a000b048:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
 */                                                                   
                                                                      
rtems_status_code rtems_task_wake_when(                               
  rtems_time_of_day *time_buffer                                      
)                                                                     
{                                                                     
a000b04c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  Watchdog_Interval   seconds;                                        
                                                                      
  if ( !_TOD_Is_set )                                                 
a000b050:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000b054:	0a000011 	beq	a000b0a0 <rtems_task_wake_when+0x60>          <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !time_buffer )                                                 
a000b058:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000b05c:	0a000029 	beq	a000b108 <rtems_task_wake_when+0xc8>          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  time_buffer->ticks = 0;                                             
a000b060:	e3a04000 	mov	r4, #0                                        <== NOT EXECUTED
a000b064:	e5804018 	str	r4, [r0, #24]                                 <== NOT EXECUTED
                                                                      
  if ( !_TOD_Validate( time_buffer ) )                                
a000b068:	ebfffcfb 	bl	a000a45c <_TOD_Validate>                       <== NOT EXECUTED
a000b06c:	e1500004 	cmp	r0, r4                                        <== NOT EXECUTED
a000b070:	1a000001 	bne	a000b07c <rtems_task_wake_when+0x3c>          <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
a000b074:	e3a00014 	mov	r0, #20                                       <== NOT EXECUTED
a000b078:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  seconds = _TOD_To_seconds( time_buffer );                           
a000b07c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000b080:	ebfffcce 	bl	a000a3c0 <_TOD_To_seconds>                     <== NOT EXECUTED
                                                                      
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a000b084:	e59f6088 	ldr	r6, [pc, #136]	; a000b114 <rtems_task_wake_when+0xd4><== NOT EXECUTED
  time_buffer->ticks = 0;                                             
                                                                      
  if ( !_TOD_Validate( time_buffer ) )                                
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( time_buffer );                           
a000b088:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a000b08c:	e5963000 	ldr	r3, [r6]                                      <== NOT EXECUTED
a000b090:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000b094:	8a000003 	bhi	a000b0a8 <rtems_task_wake_when+0x68>          <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
a000b098:	e3a00014 	mov	r0, #20                                       <== NOT EXECUTED
      &_Thread_Executing->Timer,                                      
      seconds - _TOD_Seconds_since_epoch()                            
    );                                                                
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000b09c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
)                                                                     
{                                                                     
  Watchdog_Interval   seconds;                                        
                                                                      
  if ( !_TOD_Is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
a000b0a0:	e3a0000b 	mov	r0, #11                                       <== NOT EXECUTED
a000b0a4:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
a000b0a8:	e59f3068 	ldr	r3, [pc, #104]	; a000b118 <rtems_task_wake_when+0xd8><== NOT EXECUTED
a000b0ac:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000b0b0:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000b0b4:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  _Thread_Disable_dispatch();                                         
    _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );  
a000b0b8:	e59f705c 	ldr	r7, [pc, #92]	; a000b11c <rtems_task_wake_when+0xdc><== NOT EXECUTED
a000b0bc:	e3a01010 	mov	r1, #16                                       <== NOT EXECUTED
a000b0c0:	e5970004 	ldr	r0, [r7, #4]                                  <== NOT EXECUTED
a000b0c4:	eb000a39 	bl	a000d9b0 <_Thread_Set_state>                   <== NOT EXECUTED
    _Watchdog_Initialize(                                             
      &_Thread_Executing->Timer,                                      
a000b0c8:	e5971004 	ldr	r1, [r7, #4]                                  <== NOT EXECUTED
      _Thread_Delay_ended,                                            
      _Thread_Executing->Object.id,                                   
      NULL                                                            
    );                                                                
    _Watchdog_Insert_seconds(                                         
a000b0cc:	e5962000 	ldr	r2, [r6]                                      <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a000b0d0:	e59f0048 	ldr	r0, [pc, #72]	; a000b120 <rtems_task_wake_when+0xe0><== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  _Thread_Disable_dispatch();                                         
    _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );  
    _Watchdog_Initialize(                                             
a000b0d4:	e5913008 	ldr	r3, [r1, #8]                                  <== NOT EXECUTED
      &_Thread_Executing->Timer,                                      
      _Thread_Delay_ended,                                            
      _Thread_Executing->Object.id,                                   
      NULL                                                            
    );                                                                
    _Watchdog_Insert_seconds(                                         
a000b0d8:	e0625005 	rsb	r5, r2, r5                                    <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a000b0dc:	e59f2040 	ldr	r2, [pc, #64]	; a000b124 <rtems_task_wake_when+0xe4><== NOT EXECUTED
  the_watchdog->id        = id;                                       
a000b0e0:	e5813068 	str	r3, [r1, #104]	; 0x68                         <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000b0e4:	e5814050 	str	r4, [r1, #80]	; 0x50                          <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a000b0e8:	e5812064 	str	r2, [r1, #100]	; 0x64                         <== NOT EXECUTED
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
a000b0ec:	e581406c 	str	r4, [r1, #108]	; 0x6c                         <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000b0f0:	e5815054 	str	r5, [r1, #84]	; 0x54                          <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a000b0f4:	e2811048 	add	r1, r1, #72	; 0x48                            <== NOT EXECUTED
a000b0f8:	eb000bbe 	bl	a000dff8 <_Watchdog_Insert>                    <== NOT EXECUTED
      &_Thread_Executing->Timer,                                      
      seconds - _TOD_Seconds_since_epoch()                            
    );                                                                
  _Thread_Enable_dispatch();                                          
a000b0fc:	eb000812 	bl	a000d14c <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a000b100:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000b104:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      
  if ( !_TOD_Is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !time_buffer )                                                 
    return RTEMS_INVALID_ADDRESS;                                     
a000b108:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
a000b10c:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
                                                                      

a000936c <rtems_termios_baud_to_index>: rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) {
a000936c:	e3500009 	cmp	r0, #9                                        <== NOT EXECUTED
a0009370:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009374:	da000013 	ble	a00093c8 <rtems_termios_baud_to_index+0x5c>   <== NOT EXECUTED
a0009378:	e350000e 	cmp	r0, #14                                       <== NOT EXECUTED
a000937c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009380:	da00001b 	ble	a00093f4 <rtems_termios_baud_to_index+0x88>   <== NOT EXECUTED
a0009384:	e3a03a01 	mov	r3, #4096	; 0x1000                            <== NOT EXECUTED
a0009388:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
a000938c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    case B4800:     baud_index = 12;  break;                          
    case B9600:     baud_index = 13;  break;                          
    case B19200:    baud_index = 14;  break;                          
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
a0009390:	03a00011 	moveq	r0, #17                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a0009394:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009398:	da000028 	ble	a0009440 <rtems_termios_baud_to_index+0xd4>   <== NOT EXECUTED
a000939c:	e3a03a01 	mov	r3, #4096	; 0x1000                            <== NOT EXECUTED
a00093a0:	e2833003 	add	r3, r3, #3                                    <== NOT EXECUTED
a00093a4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
    case B9600:     baud_index = 13;  break;                          
    case B19200:    baud_index = 14;  break;                          
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
a00093a8:	03a00012 	moveq	r0, #18                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a00093ac:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a00093b0:	e3a03a01 	mov	r3, #4096	; 0x1000                            <== NOT EXECUTED
a00093b4:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
a00093b8:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00093bc:	1a00001d 	bne	a0009438 <rtems_termios_baud_to_index+0xcc>   <== NOT EXECUTED
    case B19200:    baud_index = 14;  break;                          
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
a00093c0:	e3a00013 	mov	r0, #19                                       <== NOT EXECUTED
a00093c4:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a00093c8:	e3500004 	cmp	r0, #4                                        <== NOT EXECUTED
a00093cc:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a00093d0:	ca000010 	bgt	a0009418 <rtems_termios_baud_to_index+0xac>   <== NOT EXECUTED
a00093d4:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a00093d8:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a00093dc:	da00001f 	ble	a0009460 <rtems_termios_baud_to_index+0xf4>   <== NOT EXECUTED
a00093e0:	e3500002 	cmp	r0, #2                                        <== NOT EXECUTED
a00093e4:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a00093e8:	e3500003 	cmp	r0, #3                                        <== NOT EXECUTED
a00093ec:	1a000011 	bne	a0009438 <rtems_termios_baud_to_index+0xcc>   <== NOT EXECUTED
a00093f0:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
a00093f4:	e350000b 	cmp	r0, #11                                       <== NOT EXECUTED
a00093f8:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    case B150:      baud_index =  5;  break;                          
    case B200:      baud_index =  6;  break;                          
    case B300:      baud_index =  7;  break;                          
    case B600:      baud_index =  8;  break;                          
    case B1200:     baud_index =  9;  break;                          
    case B1800:     baud_index = 10;  break;                          
a00093fc:	b3a0000a 	movlt	r0, #10                                     <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a0009400:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
a0009404:	e350000c 	cmp	r0, #12                                       <== NOT EXECUTED
a0009408:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a000940c:	e350000d 	cmp	r0, #13                                       <== NOT EXECUTED
a0009410:	1a000008 	bne	a0009438 <rtems_termios_baud_to_index+0xcc>   <== NOT EXECUTED
a0009414:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
a0009418:	e3500006 	cmp	r0, #6                                        <== NOT EXECUTED
a000941c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    case B0:        baud_index =  0;  break;                          
    case B50:       baud_index =  1;  break;                          
    case B75:       baud_index =  2;  break;                          
    case B110:      baud_index =  3;  break;                          
    case B134:      baud_index =  4;  break;                          
    case B150:      baud_index =  5;  break;                          
a0009420:	b3a00005 	movlt	r0, #5                                      <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a0009424:	b12fff1e 	bxlt	lr                                           <== NOT EXECUTED
a0009428:	e3500007 	cmp	r0, #7                                        <== NOT EXECUTED
a000942c:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009430:	e3500008 	cmp	r0, #8                                        <== NOT EXECUTED
a0009434:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
    case B115200:   baud_index = 17;  break;                          
    case B230400:   baud_index = 18;  break;                          
    case B460800:   baud_index = 19;  break;                          
    default:        baud_index = -1;  break;                          
a0009438:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return baud_index;                                                  
}                                                                     
a000943c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a0009440:	e350000f 	cmp	r0, #15                                       <== NOT EXECUTED
a0009444:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009448:	e3a03a01 	mov	r3, #4096	; 0x1000                            <== NOT EXECUTED
a000944c:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a0009450:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0009454:	1afffff7 	bne	a0009438 <rtems_termios_baud_to_index+0xcc>   <== NOT EXECUTED
    case B2400:     baud_index = 11;  break;                          
    case B4800:     baud_index = 12;  break;                          
    case B9600:     baud_index = 13;  break;                          
    case B19200:    baud_index = 14;  break;                          
    case B38400:    baud_index = 15;  break;                          
    case B57600:    baud_index = 16;  break;                          
a0009458:	e3a00010 	mov	r0, #16                                       <== NOT EXECUTED
a000945c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
a0009460:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0009464:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
a0009468:	eafffff2 	b	a0009438 <rtems_termios_baud_to_index+0xcc>     <== NOT EXECUTED
                                                                      

a000946c <rtems_termios_baud_to_number>: extern rtems_assoc_t termios_assoc_table[]; int32_t rtems_termios_baud_to_number( int termios_baud ) {
a000946c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int baud;                                                           
                                                                      
  baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
a0009470:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];                           
                                                                      
int32_t rtems_termios_baud_to_number(                                 
  int termios_baud                                                    
)                                                                     
{                                                                     
a0009474:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int baud;                                                           
                                                                      
  baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
a0009478:	e59f001c 	ldr	r0, [pc, #28]	; a000949c <rtems_termios_baud_to_number+0x30><== NOT EXECUTED
a000947c:	eb001cae 	bl	a001073c <rtems_assoc_local_by_remote>         <== NOT EXECUTED
  if ( baud == 0 && termios_baud != 0 )                               
a0009480:	e2703001 	rsbs	r3, r0, #1                                   <== NOT EXECUTED
a0009484:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
a0009488:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000948c:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a0009490:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return -1;                                                        
                                                                      
  return baud;                                                        
}                                                                     
a0009494:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0009498:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0007a14 <rtems_termios_bufsize>: int cbufsize, int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize;
a0007a14:	e59f300c 	ldr	r3, [pc, #12]	; a0007a28 <rtems_termios_bufsize+0x14><== NOT EXECUTED
a0007a18:	e5830008 	str	r0, [r3, #8]                                  <== NOT EXECUTED
  rtems_termios_raw_input_size  = raw_input;                          
a0007a1c:	e8830006 	stm	r3, {r1, r2}                                  <== NOT EXECUTED
  rtems_termios_raw_output_size = raw_output;                         
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0007a20:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007a24:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a0007858 <rtems_termios_close>: } } rtems_status_code rtems_termios_close (void *arg) {
a0007858:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
a000785c:	e59f51a0 	ldr	r5, [pc, #416]	; a0007a04 <rtems_termios_close+0x1ac><== NOT EXECUTED
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
a0007860:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
a0007864:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
a0007868:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
a000786c:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0007870:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
a0007874:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
a0007878:	eb00087b 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
a000787c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007880:	1a00005e 	bne	a0007a00 <rtems_termios_close+0x1a8>          <== NOT EXECUTED
    rtems_fatal_error_occurred (sc);                                  
  if (--tty->refcount == 0) {                                         
a0007884:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0007888:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a000788c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007890:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
a0007894:	1a00002e 	bne	a0007954 <rtems_termios_close+0xfc>           <== NOT EXECUTED
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
a0007898:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         <== NOT EXECUTED
a000789c:	e59f3164 	ldr	r3, [pc, #356]	; a0007a08 <rtems_termios_close+0x1b0><== NOT EXECUTED
a00078a0:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
a00078a4:	e5931004 	ldr	r1, [r3, #4]                                  <== NOT EXECUTED
a00078a8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a00078ac:	0a00003d 	beq	a00079a8 <rtems_termios_close+0x150>          <== NOT EXECUTED
      /*                                                              
       * call discipline-specific close                               
       */                                                             
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
a00078b0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00078b4:	e12fff31 	blx	r1                                            <== NOT EXECUTED
      }                                                               
      drainOutput (tty);                                              
      rtems_semaphore_release (tty->osem);                            
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
a00078b8:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a00078bc:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a00078c0:	0a000044 	beq	a00079d8 <rtems_termios_close+0x180>          <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
    if (tty->device.lastClose)                                        
a00078c4:	e594309c 	ldr	r3, [r4, #156]	; 0x9c                         <== NOT EXECUTED
a00078c8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00078cc:	0a000003 	beq	a00078e0 <rtems_termios_close+0x88>           <== NOT EXECUTED
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
a00078d0:	e594000c 	ldr	r0, [r4, #12]                                 <== NOT EXECUTED
a00078d4:	e5941010 	ldr	r1, [r4, #16]                                 <== NOT EXECUTED
a00078d8:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a00078dc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    if (tty->forw == NULL) {                                          
a00078e0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00078e4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00078e8:	0a000026 	beq	a0007988 <rtems_termios_close+0x130>          <== NOT EXECUTED
      rtems_termios_ttyTail = tty->back;                              
      if ( rtems_termios_ttyTail != NULL ) {                          
        rtems_termios_ttyTail->forw = NULL;                           
      }                                                               
    } else {                                                          
      tty->forw->back = tty->back;                                    
a00078ec:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a00078f0:	e5832004 	str	r2, [r3, #4]                                  <== NOT EXECUTED
a00078f4:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
a00078f8:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a00078fc:	0a00001b 	beq	a0007970 <rtems_termios_close+0x118>          <== NOT EXECUTED
      rtems_termios_ttyHead = tty->forw;                              
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
      }                                                               
    } else {                                                          
      tty->back->forw = tty->forw;                                    
a0007900:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_semaphore_delete (tty->isem);                               
a0007904:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a0007908:	eb00082e 	bl	a00099c8 <rtems_semaphore_delete>              <== NOT EXECUTED
    rtems_semaphore_delete (tty->osem);                               
a000790c:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a0007910:	eb00082c 	bl	a00099c8 <rtems_semaphore_delete>              <== NOT EXECUTED
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
a0007914:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
a0007918:	eb00082a 	bl	a00099c8 <rtems_semaphore_delete>              <== NOT EXECUTED
    if ((tty->device.pollRead == NULL) ||                             
a000791c:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a0007920:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007924:	0a00000e 	beq	a0007964 <rtems_termios_close+0x10c>          <== NOT EXECUTED
a0007928:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a000792c:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0007930:	0a00000b 	beq	a0007964 <rtems_termios_close+0x10c>          <== NOT EXECUTED
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
    free (tty->rawInBuf.theBuf);                                      
a0007934:	e5940058 	ldr	r0, [r4, #88]	; 0x58                          <== NOT EXECUTED
a0007938:	ebfffa8d 	bl	a0006374 <free>                                <== NOT EXECUTED
    free (tty->rawOutBuf.theBuf);                                     
a000793c:	e594007c 	ldr	r0, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a0007940:	ebfffa8b 	bl	a0006374 <free>                                <== NOT EXECUTED
    free (tty->cbuf);                                                 
a0007944:	e594001c 	ldr	r0, [r4, #28]                                 <== NOT EXECUTED
a0007948:	ebfffa89 	bl	a0006374 <free>                                <== NOT EXECUTED
    free (tty);                                                       
a000794c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007950:	ebfffa87 	bl	a0006374 <free>                                <== NOT EXECUTED
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
a0007954:	e5950000 	ldr	r0, [r5]                                      <== NOT EXECUTED
a0007958:	eb00088c 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000795c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007960:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
    rtems_semaphore_delete (tty->isem);                               
    rtems_semaphore_delete (tty->osem);                               
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
a0007964:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
a0007968:	eb000816 	bl	a00099c8 <rtems_semaphore_delete>              <== NOT EXECUTED
a000796c:	eafffff0 	b	a0007934 <rtems_termios_close+0xdc>             <== NOT EXECUTED
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
a0007970:	e59f2094 	ldr	r2, [pc, #148]	; a0007a0c <rtems_termios_close+0x1b4><== NOT EXECUTED
      if ( rtems_termios_ttyHead != NULL ) {                          
a0007974:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
a0007978:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
a000797c:	13a02000 	movne	r2, #0                                      <== NOT EXECUTED
a0007980:	15832004 	strne	r2, [r3, #4]                                <== NOT EXECUTED
a0007984:	eaffffde 	b	a0007904 <rtems_termios_close+0xac>             <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
    if (tty->device.lastClose)                                        
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
    if (tty->forw == NULL) {                                          
      rtems_termios_ttyTail = tty->back;                              
a0007988:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a000798c:	e59f107c 	ldr	r1, [pc, #124]	; a0007a10 <rtems_termios_close+0x1b8><== NOT EXECUTED
      if ( rtems_termios_ttyTail != NULL ) {                          
a0007990:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
    if (tty->device.lastClose)                                        
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
    if (tty->forw == NULL) {                                          
      rtems_termios_ttyTail = tty->back;                              
a0007994:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
      if ( rtems_termios_ttyTail != NULL ) {                          
a0007998:	0afffff4 	beq	a0007970 <rtems_termios_close+0x118>          <== NOT EXECUTED
        rtems_termios_ttyTail->forw = NULL;                           
a000799c:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
a00079a0:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a00079a4:	eaffffd5 	b	a0007900 <rtems_termios_close+0xa8>             <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
    } else {                                                          
      /*                                                              
       * default: just flush output buffer                            
       */                                                             
      sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a00079a8:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a00079ac:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a00079b0:	eb00082d 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL) {                                   
a00079b4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00079b8:	1a000010 	bne	a0007a00 <rtems_termios_close+0x1a8>          <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      }                                                               
      drainOutput (tty);                                              
a00079bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a00079c0:	ebfffe54 	bl	a0007318 <drainOutput>                         <== NOT EXECUTED
      rtems_semaphore_release (tty->osem);                            
a00079c4:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a00079c8:	eb000870 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
a00079cc:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a00079d0:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a00079d4:	1affffba 	bne	a00078c4 <rtems_termios_close+0x6c>           <== NOT EXECUTED
      /*                                                              
       * send "terminate" to I/O tasks                                
       */                                                             
      sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
a00079d8:	e59400c4 	ldr	r0, [r4, #196]	; 0xc4                         <== NOT EXECUTED
a00079dc:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00079e0:	eb0006fe 	bl	a00095e0 <rtems_event_send>                    <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL)                                     
a00079e4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00079e8:	1a000004 	bne	a0007a00 <rtems_termios_close+0x1a8>          <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
a00079ec:	e59400c8 	ldr	r0, [r4, #200]	; 0xc8                         <== NOT EXECUTED
a00079f0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00079f4:	eb0006f9 	bl	a00095e0 <rtems_event_send>                    <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL)                                     
a00079f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00079fc:	0affffb0 	beq	a00078c4 <rtems_termios_close+0x6c>           <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
a0007a00:	eb0009c0 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0008fb4 <rtems_termios_dequeue_characters>: rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len;
a0008fb4:	e590c090 	ldr	ip, [r0, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
a0008fb8:	e59020b4 	ldr	r2, [r0, #180]	; 0xb4                         <== NOT EXECUTED
 * for each transmitted character.                                    
 * It returns number of characters left to transmit                   
 */                                                                   
int                                                                   
rtems_termios_dequeue_characters (void *ttyp, int len)                
{                                                                     
a0008fbc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
a0008fc0:	e08c1001 	add	r1, ip, r1                                    <== NOT EXECUTED
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
a0008fc4:	e3520002 	cmp	r2, #2                                        <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
a0008fc8:	e5801090 	str	r1, [r0, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
a0008fcc:	0a00000b 	beq	a0009000 <rtems_termios_dequeue_characters+0x4c><== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  if (tty->t_line == PPPDISC ) {                                      
a0008fd0:	e59030cc 	ldr	r3, [r0, #204]	; 0xcc                         <== NOT EXECUTED
a0008fd4:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
a0008fd8:	0a000001 	beq	a0008fe4 <rtems_termios_dequeue_characters+0x30><== NOT EXECUTED
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
}                                                                     
a0008fdc:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
a0008fe0:	eaffff56 	b	a0008d40 <rtems_termios_refill_transmitter>     <== NOT EXECUTED
                                                                      
  if (tty->t_line == PPPDISC ) {                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
a0008fe4:	e59f3038 	ldr	r3, [pc, #56]	; a0009024 <rtems_termios_dequeue_characters+0x70><== NOT EXECUTED
a0008fe8:	e59330b4 	ldr	r3, [r3, #180]	; 0xb4                         <== NOT EXECUTED
a0008fec:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008ff0:	0a000009 	beq	a000901c <rtems_termios_dequeue_characters+0x68><== NOT EXECUTED
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
a0008ff4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
a0008ff8:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0008ffc:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
    /*                                                                
     * send wake up to transmitter task                               
     */                                                               
    sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);     
a0009000:	e59000c8 	ldr	r0, [r0, #200]	; 0xc8                         <== NOT EXECUTED
a0009004:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a0009008:	eb000174 	bl	a00095e0 <rtems_event_send>                    <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
a000900c:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
      rtems_fatal_error_occurred (sc);                                
    return 0; /* nothing to output in IRQ... */                       
a0009010:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
    /*                                                                
     * send wake up to transmitter task                               
     */                                                               
    sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);     
    if (sc != RTEMS_SUCCESSFUL)                                       
a0009014:	049df004 	popeq	{pc}		; (ldreq pc, [sp], #4)                <== NOT EXECUTED
      rtems_fatal_error_occurred (sc);                                
a0009018:	eb00043a 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
a000901c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
}                                                                     
a0009020:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a00089d4 <rtems_termios_enqueue_raw_characters>: * device receive interrupt handler. * Returns the number of characters dropped because of overflow. */ int rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len) {
a00089d4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  char c;                                                             
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
a00089d8:	e59030cc 	ldr	r3, [r0, #204]	; 0xcc                         <== NOT EXECUTED
a00089dc:	e59f72cc 	ldr	r7, [pc, #716]	; a0008cb0 <rtems_termios_enqueue_raw_characters+0x2dc><== NOT EXECUTED
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len) 
{                                                                     
a00089e0:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a00089e4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  char c;                                                             
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
a00089e8:	e0873283 	add	r3, r7, r3, lsl #5                            <== NOT EXECUTED
a00089ec:	e5939010 	ldr	r9, [r3, #16]                                 <== NOT EXECUTED
 *       device receive interrupt handler.                            
 * Returns the number of characters dropped because of overflow.      
 */                                                                   
int                                                                   
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len) 
{                                                                     
a00089f0:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a00089f4:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  char c;                                                             
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
a00089f8:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a00089fc:	0a00001c 	beq	a0008a74 <rtems_termios_enqueue_raw_characters+0xa0><== NOT EXECUTED
    while (len--) {                                                   
a0008a00:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0008a04:	0a00000a 	beq	a0008a34 <rtems_termios_enqueue_raw_characters+0x60><== NOT EXECUTED
a0008a08:	e3a08000 	mov	r8, #0                                        <== NOT EXECUTED
a0008a0c:	ea000002 	b	a0008a1c <rtems_termios_enqueue_raw_characters+0x48><== NOT EXECUTED
a0008a10:	e59430cc 	ldr	r3, [r4, #204]	; 0xcc                         <== NOT EXECUTED
a0008a14:	e0873283 	add	r3, r7, r3, lsl #5                            <== NOT EXECUTED
a0008a18:	e5939010 	ldr	r9, [r3, #16]                                 <== NOT EXECUTED
      c = *buf++;                                                     
      rtems_termios_linesw[tty->t_line].l_rint(c,tty);                
a0008a1c:	e7d50008 	ldrb	r0, [r5, r8]                                 <== NOT EXECUTED
a0008a20:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008a24:	e2888001 	add	r8, r8, #1                                    <== NOT EXECUTED
a0008a28:	e12fff39 	blx	r9                                            <== NOT EXECUTED
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
    while (len--) {                                                   
a0008a2c:	e1580006 	cmp	r8, r6                                        <== NOT EXECUTED
a0008a30:	1afffff6 	bne	a0008a10 <rtems_termios_enqueue_raw_characters+0x3c><== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
a0008a34:	e594a0e4 	ldr	sl, [r4, #228]	; 0xe4                         <== NOT EXECUTED
a0008a38:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
a0008a3c:	13a0a000 	movne	sl, #0                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
a0008a40:	1a000008 	bne	a0008a68 <rtems_termios_enqueue_raw_characters+0x94><== NOT EXECUTED
a0008a44:	e59430dc 	ldr	r3, [r4, #220]	; 0xdc                         <== NOT EXECUTED
a0008a48:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
a0008a4c:	01a0a003 	moveq	sl, r3                                      <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
a0008a50:	0a000004 	beq	a0008a68 <rtems_termios_enqueue_raw_characters+0x94><== NOT EXECUTED
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
a0008a54:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
a0008a58:	e59410e0 	ldr	r1, [r4, #224]	; 0xe0                         <== NOT EXECUTED
a0008a5c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
a0008a60:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0008a64:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
  return dropped;                                                     
}                                                                     
a0008a68:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0008a6c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0008a70:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
a0008a74:	e2803030 	add	r3, r0, #48	; 0x30                            <== NOT EXECUTED
a0008a78:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
a0008a7c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
a0008a80:	e280304a 	add	r3, r0, #74	; 0x4a                            <== NOT EXECUTED
a0008a84:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
a0008a88:	e1a0b009 	mov	fp, r9                                        <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
a0008a8c:	0a000042 	beq	a0008b9c <rtems_termios_enqueue_raw_characters+0x1c8><== NOT EXECUTED
    c = *buf++;                                                       
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
a0008a90:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
    c = *buf++;                                                       
a0008a94:	e4d58001 	ldrb	r8, [r5], #1                                 <== NOT EXECUTED
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
a0008a98:	e3130c02 	tst	r3, #512	; 0x200                              <== NOT EXECUTED
a0008a9c:	0a000005 	beq	a0008ab8 <rtems_termios_enqueue_raw_characters+0xe4><== NOT EXECUTED
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
a0008aa0:	e5d4304a 	ldrb	r3, [r4, #74]	; 0x4a                         <== NOT EXECUTED
a0008aa4:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
a0008aa8:	0a000056 	beq	a0008c08 <rtems_termios_enqueue_raw_characters+0x234><== NOT EXECUTED
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
        }                                                             
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
a0008aac:	e5d43049 	ldrb	r3, [r4, #73]	; 0x49                         <== NOT EXECUTED
a0008ab0:	e1530008 	cmp	r3, r8                                        <== NOT EXECUTED
a0008ab4:	0a00003f 	beq	a0008bb8 <rtems_termios_enqueue_raw_characters+0x1e4><== NOT EXECUTED
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
        flow_rcv = true;                                              
      }                                                               
    }                                                                 
    if (flow_rcv) {                                                   
a0008ab8:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a0008abc:	1a000041 	bne	a0008bc8 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
a0008ac0:	e5940060 	ldr	r0, [r4, #96]	; 0x60                          <== NOT EXECUTED
a0008ac4:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
a0008ac8:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a0008acc:	eb002f8c 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a0008ad0:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008ad4:	e10fa000 	mrs	sl, CPSR                                      <== NOT EXECUTED
a0008ad8:	e38a3080 	orr	r3, sl, #128	; 0x80                           <== NOT EXECUTED
a0008adc:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
a0008ae0:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0008ae4:	e5940064 	ldr	r0, [r4, #100]	; 0x64                         <== NOT EXECUTED
            % tty->rawInBuf.Size) > tty->highwater) &&                
a0008ae8:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
a0008aec:	e0630000 	rsb	r0, r3, r0                                    <== NOT EXECUTED
            % tty->rawInBuf.Size) > tty->highwater) &&                
a0008af0:	e0800007 	add	r0, r0, r7                                    <== NOT EXECUTED
a0008af4:	eb002f82 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
a0008af8:	e59430c0 	ldr	r3, [r4, #192]	; 0xc0                         <== NOT EXECUTED
a0008afc:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0008b00:	9a00000f 	bls	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
a0008b04:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
            % tty->rawInBuf.Size) > tty->highwater) &&                
a0008b08:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a0008b0c:	1a00000c 	bne	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
a0008b10:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
a0008b14:	e3a03b01 	mov	r3, #1024	; 0x400                             <== NOT EXECUTED
a0008b18:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
      rtems_interrupt_disable(level);                                 
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
a0008b1c:	e3822001 	orr	r2, r2, #1                                    <== NOT EXECUTED
a0008b20:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
a0008b24:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0008b28:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
a0008b2c:	e3530b01 	cmp	r3, #1024	; 0x400                             <== NOT EXECUTED
a0008b30:	0a000046 	beq	a0008c50 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
a0008b34:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0008b38:	e2033f41 	and	r3, r3, #260	; 0x104                          <== NOT EXECUTED
a0008b3c:	e3530c01 	cmp	r3, #256	; 0x100                              <== NOT EXECUTED
a0008b40:	0a000051 	beq	a0008c8c <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008b44:	e129f00a 	msr	CPSR_fc, sl                                   <== NOT EXECUTED
      }                                                               
                                                                      
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
a0008b48:	e594305c 	ldr	r3, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0008b4c:	e1530007 	cmp	r3, r7                                        <== NOT EXECUTED
        dropped++;                                                    
a0008b50:	028bb001 	addeq	fp, fp, #1                                  <== NOT EXECUTED
      }                                                               
                                                                      
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
a0008b54:	0a00000d 	beq	a0008b90 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
a0008b58:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
a0008b5c:	e7c38007 	strb	r8, [r3, r7]                                 <== NOT EXECUTED
        tty->rawInBuf.Tail = newTail;                                 
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
a0008b60:	e59430e4 	ldr	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
        tty->rawInBuf.Tail = newTail;                                 
a0008b64:	e5847060 	str	r7, [r4, #96]	; 0x60                          <== NOT EXECUTED
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
a0008b68:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008b6c:	1a000007 	bne	a0008b90 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
a0008b70:	e59430dc 	ldr	r3, [r4, #220]	; 0xdc                         <== NOT EXECUTED
a0008b74:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008b78:	0a000004 	beq	a0008b90 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
a0008b7c:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a0008b80:	e59410e0 	ldr	r1, [r4, #224]	; 0xe0                         <== NOT EXECUTED
a0008b84:	e12fff33 	blx	r3                                            <== NOT EXECUTED
          tty->tty_rcvwakeup = 1;                                     
a0008b88:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0008b8c:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
a0008b90:	e2466001 	sub	r6, r6, #1                                    <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
a0008b94:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0008b98:	1affffbc 	bne	a0008a90 <rtems_termios_enqueue_raw_characters+0xbc><== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
a0008b9c:	e5943078 	ldr	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
a0008ba0:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
a0008ba4:	e1a0a00b 	mov	sl, fp                                        <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
a0008ba8:	e083300b 	add	r3, r3, fp                                    <== NOT EXECUTED
a0008bac:	e5843078 	str	r3, [r4, #120]	; 0x78                         <== NOT EXECUTED
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
a0008bb0:	eb0003f6 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  return dropped;                                                     
a0008bb4:	eaffffab 	b	a0008a68 <rtems_termios_enqueue_raw_characters+0x94><== NOT EXECUTED
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
        /* VSTART received */                                         
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
a0008bb8:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
    while (len--) {                                                   
a0008bbc:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
        /* VSTART received */                                         
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
a0008bc0:	e3c33010 	bic	r3, r3, #16                                   <== NOT EXECUTED
a0008bc4:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        flow_rcv = true;                                              
      }                                                               
    }                                                                 
    if (flow_rcv) {                                                   
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
a0008bc8:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0008bcc:	e2033030 	and	r3, r3, #48	; 0x30                            <== NOT EXECUTED
a0008bd0:	e3530020 	cmp	r3, #32                                       <== NOT EXECUTED
a0008bd4:	1affffed 	bne	a0008b90 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008bd8:	e10f7000 	mrs	r7, CPSR                                      <== NOT EXECUTED
a0008bdc:	e3873080 	orr	r3, r7, #128	; 0x80                           <== NOT EXECUTED
a0008be0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
        tty->flow_ctrl &= ~FL_OSTOP;                                  
a0008be4:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
a0008be8:	e5942094 	ldr	r2, [r4, #148]	; 0x94                         <== NOT EXECUTED
    if (flow_rcv) {                                                   
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
        tty->flow_ctrl &= ~FL_OSTOP;                                  
a0008bec:	e3c33020 	bic	r3, r3, #32                                   <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
a0008bf0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    if (flow_rcv) {                                                   
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
        tty->flow_ctrl &= ~FL_OSTOP;                                  
a0008bf4:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
a0008bf8:	1a00000c 	bne	a0008c30 <rtems_termios_enqueue_raw_characters+0x25c><== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008bfc:	e129f007 	msr	CPSR_fc, r7                                   <== NOT EXECUTED
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
          tty->tty_rcvwakeup = 1;                                     
a0008c00:	e2466001 	sub	r6, r6, #1                                    <== NOT EXECUTED
a0008c04:	eaffffe2 	b	a0008b94 <rtems_termios_enqueue_raw_characters+0x1c0><== NOT EXECUTED
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
a0008c08:	e5d42049 	ldrb	r2, [r4, #73]	; 0x49                         <== NOT EXECUTED
  int dropped = 0;                                                    
  bool flow_rcv = false; /* true, if flow control char received */    
  rtems_interrupt_level level;                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {             
    while (len--) {                                                   
a0008c0c:	e3a09001 	mov	r9, #1                                        <== NOT EXECUTED
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
a0008c10:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
          /* received VSTOP and VSTART==VSTOP? */                     
          /* then toggle "stop output" status  */                     
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
a0008c14:	059430b8 	ldreq	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
        }                                                             
        else {                                                        
          /* VSTOP received (other code than VSTART) */               
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
a0008c18:	159430b8 	ldrne	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
          /* received VSTOP and VSTART==VSTOP? */                     
          /* then toggle "stop output" status  */                     
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
a0008c1c:	02233010 	eoreq	r3, r3, #16                                 <== NOT EXECUTED
        }                                                             
        else {                                                        
          /* VSTOP received (other code than VSTART) */               
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
a0008c20:	13833010 	orrne	r3, r3, #16                                 <== NOT EXECUTED
      /* if received char is V_STOP and V_START (both are equal value) */
      if (c == tty->termios.c_cc[VSTOP]) {                            
        if (c == tty->termios.c_cc[VSTART]) {                         
          /* received VSTOP and VSTART==VSTOP? */                     
          /* then toggle "stop output" status  */                     
          tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;               
a0008c24:	058430b8 	streq	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
        }                                                             
        else {                                                        
          /* VSTOP received (other code than VSTART) */               
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
a0008c28:	158430b8 	strne	r3, [r4, #184]	; 0xb8                       <== NOT EXECUTED
a0008c2c:	eaffffe5 	b	a0008bc8 <rtems_termios_enqueue_raw_characters+0x1f4><== NOT EXECUTED
        tty->flow_ctrl &= ~FL_OSTOP;                                  
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
          /* if chars available, call write function... */            
          (*tty->device.write)(                                       
            tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
a0008c30:	e5942084 	ldr	r2, [r4, #132]	; 0x84                         <== NOT EXECUTED
        rtems_interrupt_disable(level);                               
        tty->flow_ctrl &= ~FL_OSTOP;                                  
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
          /* if chars available, call write function... */            
          (*tty->device.write)(                                       
a0008c34:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a0008c38:	e59430a4 	ldr	r3, [r4, #164]	; 0xa4                         <== NOT EXECUTED
a0008c3c:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0008c40:	e0811002 	add	r1, r1, r2                                    <== NOT EXECUTED
a0008c44:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0008c48:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008c4c:	eaffffea 	b	a0008bfc <rtems_termios_enqueue_raw_characters+0x228><== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
a0008c50:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0008c54:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a0008c58:	1a000002 	bne	a0008c68 <rtems_termios_enqueue_raw_characters+0x294><== NOT EXECUTED
a0008c5c:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
a0008c60:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008c64:	1affffb6 	bne	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
a0008c68:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
a0008c6c:	e59430a4 	ldr	r3, [r4, #164]	; 0xa4                         <== NOT EXECUTED
a0008c70:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
              (tty->rawOutBufState == rob_idle)) {                    
            /* if tx is stopped due to XOFF or out of data */         
            /*    call write function here                 */         
            tty->flow_ctrl |= FL_ISNTXOF;                             
a0008c74:	e3822002 	orr	r2, r2, #2                                    <== NOT EXECUTED
a0008c78:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
a0008c7c:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
a0008c80:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0008c84:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008c88:	eaffffad 	b	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
          tty->flow_ctrl |= FL_IRTSOFF;                               
a0008c8c:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
a0008c90:	e59430ac 	ldr	r3, [r4, #172]	; 0xac                         <== NOT EXECUTED
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
          tty->flow_ctrl |= FL_IRTSOFF;                               
a0008c94:	e3822004 	orr	r2, r2, #4                                    <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
a0008c98:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
            tty->flow_ctrl |= FL_ISNTXOF;                             
            (*tty->device.write)(tty->minor,                          
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
          tty->flow_ctrl |= FL_IRTSOFF;                               
a0008c9c:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
a0008ca0:	0affffa7 	beq	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
            tty->device.stopRemoteTx(tty->minor);                     
a0008ca4:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0008ca8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008cac:	eaffffa4 	b	a0008b44 <rtems_termios_enqueue_raw_characters+0x170><== NOT EXECUTED
                                                                      

a0007a2c <rtems_termios_ioctl>: rtems_status_code rtems_termios_ioctl (void *arg) { rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
a0007a2c:	e5902000 	ldr	r2, [r0]                                      <== NOT EXECUTED
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
a0007a30:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
a0007a34:	e5925034 	ldr	r5, [r2, #52]	; 0x34                          <== NOT EXECUTED
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
  rtems_status_code sc;                                               
                                                                      
   args->ioctl_return = 0;                                            
a0007a38:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
a0007a3c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
  rtems_status_code sc;                                               
                                                                      
   args->ioctl_return = 0;                                            
a0007a40:	e580300c 	str	r3, [r0, #12]                                 <== NOT EXECUTED
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0007a44:	e1a01003 	mov	r1, r3                                        <== NOT EXECUTED
a0007a48:	e1a02003 	mov	r2, r3                                        <== NOT EXECUTED
a0007a4c:	e5950018 	ldr	r0, [r5, #24]                                 <== NOT EXECUTED
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
a0007a50:	e5947008 	ldr	r7, [r4, #8]                                  <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
   args->ioctl_return = 0;                                            
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0007a54:	eb000804 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
a0007a58:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0007a5c:	1a00000e 	bne	a0007a9c <rtems_termios_ioctl+0x70>           <== NOT EXECUTED
    args->ioctl_return = sc;                                          
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
a0007a60:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a0007a64:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a0007a68:	0a000006 	beq	a0007a88 <rtems_termios_ioctl+0x5c>           <== NOT EXECUTED
a0007a6c:	8a00000d 	bhi	a0007aa8 <rtems_termios_ioctl+0x7c>           <== NOT EXECUTED
a0007a70:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0007a74:	0a00001d 	beq	a0007af0 <rtems_termios_ioctl+0xc4>           <== NOT EXECUTED
a0007a78:	9a000082 	bls	a0007c88 <rtems_termios_ioctl+0x25c>          <== NOT EXECUTED
    if (tty->device.setAttributes)                                    
      (*tty->device.setAttributes)(tty->minor, &tty->termios);        
    break;                                                            
                                                                      
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
a0007a7c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007a80:	ebfffe24 	bl	a0007318 <drainOutput>                         <== NOT EXECUTED
    break;                                                            
a0007a84:	ea000002 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
    break;                                                            
                                                                      
  case RTEMS_IO_RCVWAKEUP:                                            
    tty->tty_rcv = *wakeup;                                           
a0007a88:	e897000c 	ldm	r7, {r2, r3}                                  <== NOT EXECUTED
a0007a8c:	e58520dc 	str	r2, [r5, #220]	; 0xdc                         <== NOT EXECUTED
a0007a90:	e58530e0 	str	r3, [r5, #224]	; 0xe0                         <== NOT EXECUTED
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
    }                                                                 
    break;                                                            
  }                                                                   
                                                                      
  rtems_semaphore_release (tty->osem);                                
a0007a94:	e5950018 	ldr	r0, [r5, #24]                                 <== NOT EXECUTED
a0007a98:	eb00083c 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  args->ioctl_return = sc;                                            
a0007a9c:	e584600c 	str	r6, [r4, #12]                                 <== NOT EXECUTED
  return sc;                                                          
}                                                                     
a0007aa0:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007aa4:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    args->ioctl_return = sc;                                          
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
a0007aa8:	e59f2328 	ldr	r2, [pc, #808]	; a0007dd8 <rtems_termios_ioctl+0x3ac><== NOT EXECUTED
a0007aac:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0007ab0:	0a000068 	beq	a0007c58 <rtems_termios_ioctl+0x22c>          <== NOT EXECUTED
a0007ab4:	8a00007f 	bhi	a0007cb8 <rtems_termios_ioctl+0x28c>          <== NOT EXECUTED
a0007ab8:	e3530005 	cmp	r3, #5                                        <== NOT EXECUTED
a0007abc:	0a00009c 	beq	a0007d34 <rtems_termios_ioctl+0x308>          <== NOT EXECUTED
  default:                                                            
    if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {          
a0007ac0:	e59520cc 	ldr	r2, [r5, #204]	; 0xcc                         <== NOT EXECUTED
a0007ac4:	e59f3310 	ldr	r3, [pc, #784]	; a0007ddc <rtems_termios_ioctl+0x3b0><== NOT EXECUTED
a0007ac8:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
a0007acc:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0007ad0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);       
    }                                                                 
    else {                                                            
      sc = RTEMS_INVALID_NUMBER;                                      
a0007ad4:	03a0600a 	moveq	r6, #10                                     <== NOT EXECUTED
    args->ioctl_return = sc;                                          
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
  default:                                                            
    if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {          
a0007ad8:	0affffed 	beq	a0007a94 <rtems_termios_ioctl+0x68>           <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);       
a0007adc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007ae0:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0007ae4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007ae8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0007aec:	eaffffe8 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
    break;                                                            
                                                                      
  case RTEMS_IO_SET_ATTRIBUTES:                                       
    tty->termios = *(struct termios *)args->buffer;                   
a0007af0:	e594e008 	ldr	lr, [r4, #8]                                  <== NOT EXECUTED
a0007af4:	e2857030 	add	r7, r5, #48	; 0x30                            <== NOT EXECUTED
a0007af8:	e1a0c007 	mov	ip, r7                                        <== NOT EXECUTED
a0007afc:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007b00:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007b04:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007b08:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
a0007b0c:	e59580b8 	ldr	r8, [r5, #184]	; 0xb8                         <== NOT EXECUTED
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
    break;                                                            
                                                                      
  case RTEMS_IO_SET_ATTRIBUTES:                                       
    tty->termios = *(struct termios *)args->buffer;                   
a0007b10:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
a0007b14:	e3180c02 	tst	r8, #512	; 0x200                              <== NOT EXECUTED
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
    break;                                                            
                                                                      
  case RTEMS_IO_SET_ATTRIBUTES:                                       
    tty->termios = *(struct termios *)args->buffer;                   
a0007b18:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
a0007b1c:	0a000012 	beq	a0007b6c <rtems_termios_ioctl+0x140>          <== NOT EXECUTED
      !(tty->termios.c_iflag & IXON)) {                               
a0007b20:	e5953030 	ldr	r3, [r5, #48]	; 0x30                          <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
a0007b24:	e3130b01 	tst	r3, #1024	; 0x400                             <== NOT EXECUTED
a0007b28:	1a00000f 	bne	a0007b6c <rtems_termios_ioctl+0x140>          <== NOT EXECUTED
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
a0007b2c:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007b30:	e3c33e21 	bic	r3, r3, #528	; 0x210                          <== NOT EXECUTED
a0007b34:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
a0007b38:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007b3c:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a0007b40:	0a000009 	beq	a0007b6c <rtems_termios_ioctl+0x140>          <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0007b44:	e10f8000 	mrs	r8, CPSR                                      <== NOT EXECUTED
a0007b48:	e3883080 	orr	r3, r8, #128	; 0x80                           <== NOT EXECUTED
a0007b4c:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl &= ~FL_OSTOP;                                    
a0007b50:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
a0007b54:	e5952094 	ldr	r2, [r5, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl &= ~FL_OSTOP;                                    
a0007b58:	e3c33020 	bic	r3, r3, #32                                   <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
a0007b5c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl &= ~FL_OSTOP;                                    
a0007b60:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
a0007b64:	1a000093 	bne	a0007db8 <rtems_termios_ioctl+0x38c>          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0007b68:	e129f008 	msr	CPSR_fc, r8                                   <== NOT EXECUTED
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
    }                                                                 
  }                                                                   
  /* check for incoming XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
a0007b6c:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007b70:	e3130b01 	tst	r3, #1024	; 0x400                             <== NOT EXECUTED
a0007b74:	0a000008 	beq	a0007b9c <rtems_termios_ioctl+0x170>          <== NOT EXECUTED
a0007b78:	e5953030 	ldr	r3, [r5, #48]	; 0x30                          <== NOT EXECUTED
a0007b7c:	e3130a01 	tst	r3, #4096	; 0x1000                            <== NOT EXECUTED
a0007b80:	1a000005 	bne	a0007b9c <rtems_termios_ioctl+0x170>          <== NOT EXECUTED
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
a0007b84:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007b88:	e3c33b01 	bic	r3, r3, #1024	; 0x400                         <== NOT EXECUTED
a0007b8c:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
    /* FIXME: what happens, if we had sent XOFF but not yet XON? */   
    tty->flow_ctrl &= ~(FL_ISNTXOF);                                  
a0007b90:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007b94:	e3c33002 	bic	r3, r3, #2                                    <== NOT EXECUTED
a0007b98:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
  }                                                                   
                                                                      
  /* check for incoming RTS/CTS flow control switched off */          
  if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
a0007b9c:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007ba0:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0007ba4:	05952038 	ldreq	r2, [r5, #56]	; 0x38                        <== NOT EXECUTED
a0007ba8:	0a000011 	beq	a0007bf4 <rtems_termios_ioctl+0x1c8>          <== NOT EXECUTED
a0007bac:	e5952038 	ldr	r2, [r5, #56]	; 0x38                          <== NOT EXECUTED
a0007bb0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0007bb4:	ba000073 	blt	a0007d88 <rtems_termios_ioctl+0x35c>          <== NOT EXECUTED
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
a0007bb8:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007bbc:	e3c33c01 	bic	r3, r3, #256	; 0x100                          <== NOT EXECUTED
a0007bc0:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
a0007bc4:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007bc8:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a0007bcc:	0a000005 	beq	a0007be8 <rtems_termios_ioctl+0x1bc>          <== NOT EXECUTED
a0007bd0:	e59530b0 	ldr	r3, [r5, #176]	; 0xb0                         <== NOT EXECUTED
a0007bd4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007bd8:	0a000002 	beq	a0007be8 <rtems_termios_ioctl+0x1bc>          <== NOT EXECUTED
      tty->device.startRemoteTx(tty->minor);                          
a0007bdc:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
a0007be0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007be4:	e5952038 	ldr	r2, [r5, #56]	; 0x38                          <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
a0007be8:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007bec:	e3c33004 	bic	r3, r3, #4                                    <== NOT EXECUTED
a0007bf0:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * check for flow control options to be switched on                 
   */                                                                 
  /* check for incoming RTS/CTS flow control switched on */           
  if (tty->termios.c_cflag & CRTSCTS) {                               
a0007bf4:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0007bf8:	ba000062 	blt	a0007d88 <rtems_termios_ioctl+0x35c>          <== NOT EXECUTED
    tty->flow_ctrl |= FL_MDRTS;                                       
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
a0007bfc:	e5953030 	ldr	r3, [r5, #48]	; 0x30                          <== NOT EXECUTED
    tty->termios = *(struct termios *)args->buffer;                   
                                                                      
    /* check for and process change in flow control options */        
    termios_set_flowctrl(tty);                                        
                                                                      
    if (tty->termios.c_lflag & ICANON) {                              
a0007c00:	e595803c 	ldr	r8, [r5, #60]	; 0x3c                          <== NOT EXECUTED
  /* check for incoming RTS/CTS flow control switched on */           
  if (tty->termios.c_cflag & CRTSCTS) {                               
    tty->flow_ctrl |= FL_MDRTS;                                       
  }                                                                   
  /* check for incoming XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXOFF) {                                 
a0007c04:	e3130a01 	tst	r3, #4096	; 0x1000                            <== NOT EXECUTED
    tty->flow_ctrl |= FL_MDXOF;                                       
a0007c08:	159520b8 	ldrne	r2, [r5, #184]	; 0xb8                       <== NOT EXECUTED
a0007c0c:	13822b01 	orrne	r2, r2, #1024	; 0x400                       <== NOT EXECUTED
a0007c10:	158520b8 	strne	r2, [r5, #184]	; 0xb8                       <== NOT EXECUTED
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
a0007c14:	e3130b01 	tst	r3, #1024	; 0x400                             <== NOT EXECUTED
    tty->flow_ctrl |= FL_MDXON;                                       
a0007c18:	159530b8 	ldrne	r3, [r5, #184]	; 0xb8                       <== NOT EXECUTED
a0007c1c:	13833c02 	orrne	r3, r3, #512	; 0x200                        <== NOT EXECUTED
a0007c20:	158530b8 	strne	r3, [r5, #184]	; 0xb8                       <== NOT EXECUTED
    tty->termios = *(struct termios *)args->buffer;                   
                                                                      
    /* check for and process change in flow control options */        
    termios_set_flowctrl(tty);                                        
                                                                      
    if (tty->termios.c_lflag & ICANON) {                              
a0007c24:	e2188002 	ands	r8, r8, #2                                   <== NOT EXECUTED
a0007c28:	0a000045 	beq	a0007d44 <rtems_termios_ioctl+0x318>          <== NOT EXECUTED
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
a0007c2c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0007c30:	e585306c 	str	r3, [r5, #108]	; 0x6c                         <== NOT EXECUTED
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
a0007c34:	e5853070 	str	r3, [r5, #112]	; 0x70                         <== NOT EXECUTED
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
a0007c38:	e5853074 	str	r3, [r5, #116]	; 0x74                         <== NOT EXECUTED
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
        }                                                             
      }                                                               
    }                                                                 
    if (tty->device.setAttributes)                                    
a0007c3c:	e59530a8 	ldr	r3, [r5, #168]	; 0xa8                         <== NOT EXECUTED
a0007c40:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007c44:	0affff92 	beq	a0007a94 <rtems_termios_ioctl+0x68>           <== NOT EXECUTED
      (*tty->device.setAttributes)(tty->minor, &tty->termios);        
a0007c48:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
a0007c4c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0007c50:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007c54:	eaffff8e 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  case TIOCGETD:                                                      
    *(int*)(args->buffer)=tty->t_line;                                
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
a0007c58:	e5952060 	ldr	r2, [r5, #96]	; 0x60                          <== NOT EXECUTED
a0007c5c:	e595305c 	ldr	r3, [r5, #92]	; 0x5c                          <== NOT EXECUTED
      if ( rawnc < 0 )                                                
        rawnc += tty->rawInBuf.Size;                                  
      /* Half guess that this is the right operation */               
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
a0007c60:	e5950020 	ldr	r0, [r5, #32]                                 <== NOT EXECUTED
a0007c64:	e5941008 	ldr	r1, [r4, #8]                                  <== NOT EXECUTED
    *(int*)(args->buffer)=tty->t_line;                                
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
      if ( rawnc < 0 )                                                
a0007c68:	e0523003 	subs	r3, r2, r3                                   <== NOT EXECUTED
        rawnc += tty->rawInBuf.Size;                                  
a0007c6c:	45952064 	ldrmi	r2, [r5, #100]	; 0x64                       <== NOT EXECUTED
a0007c70:	40833002 	addmi	r3, r3, r2                                  <== NOT EXECUTED
      /* Half guess that this is the right operation */               
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
a0007c74:	e5952024 	ldr	r2, [r5, #36]	; 0x24                          <== NOT EXECUTED
a0007c78:	e0622000 	rsb	r2, r2, r0                                    <== NOT EXECUTED
a0007c7c:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
a0007c80:	e5813000 	str	r3, [r1]                                      <== NOT EXECUTED
    }                                                                 
    break;                                                            
a0007c84:	eaffff82 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    args->ioctl_return = sc;                                          
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
a0007c88:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a0007c8c:	1affff8b 	bne	a0007ac0 <rtems_termios_ioctl+0x94>           <== NOT EXECUTED
      sc = RTEMS_INVALID_NUMBER;                                      
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
a0007c90:	e5947008 	ldr	r7, [r4, #8]                                  <== NOT EXECUTED
a0007c94:	e285c030 	add	ip, r5, #48	; 0x30                            <== NOT EXECUTED
a0007c98:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007c9c:	e1a0e007 	mov	lr, r7                                        <== NOT EXECUTED
a0007ca0:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007ca4:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007ca8:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007cac:	e59c3000 	ldr	r3, [ip]                                      <== NOT EXECUTED
a0007cb0:	e58e3000 	str	r3, [lr]                                      <== NOT EXECUTED
    break;                                                            
a0007cb4:	eaffff76 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    args->ioctl_return = sc;                                          
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
a0007cb8:	e59f2120 	ldr	r2, [pc, #288]	; a0007de0 <rtems_termios_ioctl+0x3b4><== NOT EXECUTED
a0007cbc:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0007cc0:	0a000017 	beq	a0007d24 <rtems_termios_ioctl+0x2f8>          <== NOT EXECUTED
a0007cc4:	e2822105 	add	r2, r2, #1073741825	; 0x40000001              <== NOT EXECUTED
a0007cc8:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a0007ccc:	1affff7b 	bne	a0007ac0 <rtems_termios_ioctl+0x94>           <== NOT EXECUTED
#if 1 /* FIXME */                                                     
  case TIOCSETD:                                                      
    /*                                                                
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
a0007cd0:	e59f7104 	ldr	r7, [pc, #260]	; a0007ddc <rtems_termios_ioctl+0x3b0><== NOT EXECUTED
a0007cd4:	e59530cc 	ldr	r3, [r5, #204]	; 0xcc                         <== NOT EXECUTED
a0007cd8:	e0873283 	add	r3, r7, r3, lsl #5                            <== NOT EXECUTED
a0007cdc:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0007ce0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007ce4:	0a000002 	beq	a0007cf4 <rtems_termios_ioctl+0x2c8>          <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
a0007ce8:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007cec:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007cf0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
a0007cf4:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0007cf8:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
    tty->t_sc = NULL; /* ensure that no more valid data */            
a0007cfc:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0007d00:	e58530d0 	str	r3, [r5, #208]	; 0xd0                         <== NOT EXECUTED
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
a0007d04:	e7973282 	ldr	r3, [r7, r2, lsl #5]                          <== NOT EXECUTED
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
a0007d08:	e58520cc 	str	r2, [r5, #204]	; 0xcc                         <== NOT EXECUTED
    tty->t_sc = NULL; /* ensure that no more valid data */            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
a0007d0c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007d10:	0affff5f 	beq	a0007a94 <rtems_termios_ioctl+0x68>           <== NOT EXECUTED
      sc = rtems_termios_linesw[tty->t_line].l_open(tty);             
a0007d14:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007d18:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007d1c:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a0007d20:	eaffff5b 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
    }                                                                 
    break;                                                            
  case TIOCGETD:                                                      
    *(int*)(args->buffer)=tty->t_line;                                
a0007d24:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
a0007d28:	e59520cc 	ldr	r2, [r5, #204]	; 0xcc                         <== NOT EXECUTED
a0007d2c:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
    break;                                                            
a0007d30:	eaffff57 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
    break;                                                            
                                                                      
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
a0007d34:	e897000c 	ldm	r7, {r2, r3}                                  <== NOT EXECUTED
a0007d38:	e58520d4 	str	r2, [r5, #212]	; 0xd4                         <== NOT EXECUTED
a0007d3c:	e58530d8 	str	r3, [r5, #216]	; 0xd8                         <== NOT EXECUTED
    break;                                                            
a0007d40:	eaffff53 	b	a0007a94 <rtems_termios_ioctl+0x68>             <== NOT EXECUTED
    if (tty->termios.c_lflag & ICANON) {                              
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
a0007d44:	e5d5a046 	ldrb	sl, [r5, #70]	; 0x46                         <== NOT EXECUTED
                    rtems_clock_get_ticks_per_second() / 10;          
a0007d48:	eb00059f 	bl	a00093cc <rtems_clock_get_ticks_per_second>    <== NOT EXECUTED
a0007d4c:	e59f3090 	ldr	r3, [pc, #144]	; a0007de4 <rtems_termios_ioctl+0x3b8><== NOT EXECUTED
    if (tty->termios.c_lflag & ICANON) {                              
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
a0007d50:	e000009a 	mul	r0, sl, r0                                    <== NOT EXECUTED
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
a0007d54:	e5d52046 	ldrb	r2, [r5, #70]	; 0x46                         <== NOT EXECUTED
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
                    rtems_clock_get_ticks_per_second() / 10;          
a0007d58:	e0831390 	umull	r1, r3, r0, r3                              <== NOT EXECUTED
      if (tty->termios.c_cc[VTIME]) {                                 
a0007d5c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
                    rtems_clock_get_ticks_per_second() / 10;          
a0007d60:	e1a031a3 	lsr	r3, r3, #3                                    <== NOT EXECUTED
    if (tty->termios.c_lflag & ICANON) {                              
      tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                     
      tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;               
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
a0007d64:	e5853054 	str	r3, [r5, #84]	; 0x54                          <== NOT EXECUTED
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
a0007d68:	0a00000a 	beq	a0007d98 <rtems_termios_ioctl+0x36c>          <== NOT EXECUTED
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
a0007d6c:	e5d52047 	ldrb	r2, [r5, #71]	; 0x47                         <== NOT EXECUTED
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
a0007d70:	e5853070 	str	r3, [r5, #112]	; 0x70                         <== NOT EXECUTED
      tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;          
    } else {                                                          
      tty->vtimeTicks = tty->termios.c_cc[VTIME] *                    
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
a0007d74:	e585806c 	str	r8, [r5, #108]	; 0x6c                         <== NOT EXECUTED
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
a0007d78:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0007d7c:	13a03000 	movne	r3, #0                                      <== NOT EXECUTED
a0007d80:	e5853074 	str	r3, [r5, #116]	; 0x74                         <== NOT EXECUTED
a0007d84:	eaffffac 	b	a0007c3c <rtems_termios_ioctl+0x210>            <== NOT EXECUTED
  /*                                                                  
   * check for flow control options to be switched on                 
   */                                                                 
  /* check for incoming RTS/CTS flow control switched on */           
  if (tty->termios.c_cflag & CRTSCTS) {                               
    tty->flow_ctrl |= FL_MDRTS;                                       
a0007d88:	e59530b8 	ldr	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007d8c:	e3833c01 	orr	r3, r3, #256	; 0x100                          <== NOT EXECUTED
a0007d90:	e58530b8 	str	r3, [r5, #184]	; 0xb8                         <== NOT EXECUTED
a0007d94:	eaffff98 	b	a0007bfc <rtems_termios_ioctl+0x1d0>            <== NOT EXECUTED
        if (tty->termios.c_cc[VMIN])                                  
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
a0007d98:	e5d53047 	ldrb	r3, [r5, #71]	; 0x47                         <== NOT EXECUTED
a0007d9c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
a0007da0:	03a03001 	moveq	r3, #1                                      <== NOT EXECUTED
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
a0007da4:	1585206c 	strne	r2, [r5, #108]	; 0x6c                       <== NOT EXECUTED
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
a0007da8:	15852070 	strne	r2, [r5, #112]	; 0x70                       <== NOT EXECUTED
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
a0007dac:	15852074 	strne	r2, [r5, #116]	; 0x74                       <== NOT EXECUTED
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
a0007db0:	0585306c 	streq	r3, [r5, #108]	; 0x6c                       <== NOT EXECUTED
a0007db4:	eaffffa0 	b	a0007c3c <rtems_termios_ioctl+0x210>            <== NOT EXECUTED
      tty->flow_ctrl &= ~FL_OSTOP;                                    
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
        /* if chars available, call write function... */              
        (*tty->device.write)(                                         
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
a0007db8:	e5952084 	ldr	r2, [r5, #132]	; 0x84                         <== NOT EXECUTED
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl &= ~FL_OSTOP;                                    
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
        /* if chars available, call write function... */              
        (*tty->device.write)(                                         
a0007dbc:	e595107c 	ldr	r1, [r5, #124]	; 0x7c                         <== NOT EXECUTED
a0007dc0:	e59530a4 	ldr	r3, [r5, #164]	; 0xa4                         <== NOT EXECUTED
a0007dc4:	e5950010 	ldr	r0, [r5, #16]                                 <== NOT EXECUTED
a0007dc8:	e0811002 	add	r1, r1, r2                                    <== NOT EXECUTED
a0007dcc:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0007dd0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007dd4:	eaffff63 	b	a0007b68 <rtems_termios_ioctl+0x13c>            <== NOT EXECUTED
                                                                      

a00094e8 <rtems_termios_number_to_baud>: extern rtems_assoc_t termios_assoc_table[]; int rtems_termios_number_to_baud( int32_t baud ) {
a00094e8:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int termios_baud;                                                   
                                                                      
  termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
a00094ec:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];                           
                                                                      
int rtems_termios_number_to_baud(                                     
  int32_t baud                                                        
)                                                                     
{                                                                     
a00094f0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int termios_baud;                                                   
                                                                      
  termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
a00094f4:	e59f001c 	ldr	r0, [pc, #28]	; a0009518 <rtems_termios_number_to_baud+0x30><== NOT EXECUTED
a00094f8:	eb001cdc 	bl	a0010870 <rtems_assoc_remote_by_local>         <== NOT EXECUTED
  if ( termios_baud == 0 && baud != 0 )                               
a00094fc:	e2703001 	rsbs	r3, r0, #1                                   <== NOT EXECUTED
a0009500:	33a03000 	movcc	r3, #0                                      <== NOT EXECUTED
a0009504:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a0009508:	03a03000 	moveq	r3, #0                                      <== NOT EXECUTED
a000950c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return -1;                                                        
  return termios_baud;                                                
}                                                                     
a0009510:	13e00000 	mvnne	r0, #0                                      <== NOT EXECUTED
a0009514:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0007394 <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
a0007394:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  struct rtems_termios_tty *tty;                                      
                                                                      
  /*                                                                  
   * See if the device has already been opened                        
   */                                                                 
  sc = rtems_semaphore_obtain(                                        
a0007398:	e59f74a0 	ldr	r7, [pc, #1184]	; a0007840 <rtems_termios_open+0x4ac><== NOT EXECUTED
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
)                                                                     
{                                                                     
a000739c:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  struct rtems_termios_tty *tty;                                      
                                                                      
  /*                                                                  
   * See if the device has already been opened                        
   */                                                                 
  sc = rtems_semaphore_obtain(                                        
a00073a0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
)                                                                     
{                                                                     
a00073a4:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a00073a8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a00073ac:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
  struct rtems_termios_tty *tty;                                      
                                                                      
  /*                                                                  
   * See if the device has already been opened                        
   */                                                                 
  sc = rtems_semaphore_obtain(                                        
a00073b0:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a00073b4:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  rtems_device_major_number      major,                               
  rtems_device_minor_number      minor,                               
  void                          *arg,                                 
  const rtems_termios_callbacks *callbacks                            
)                                                                     
{                                                                     
a00073b8:	e58d3014 	str	r3, [sp, #20]                                 <== NOT EXECUTED
  struct rtems_termios_tty *tty;                                      
                                                                      
  /*                                                                  
   * See if the device has already been opened                        
   */                                                                 
  sc = rtems_semaphore_obtain(                                        
a00073bc:	eb0009aa 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
a00073c0:	e250a000 	subs	sl, r0, #0                                   <== NOT EXECUTED
a00073c4:	1a000021 	bne	a0007450 <rtems_termios_open+0xbc>            <== NOT EXECUTED
    return sc;                                                        
                                                                      
  for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 
a00073c8:	e59fb474 	ldr	fp, [pc, #1140]	; a0007844 <rtems_termios_open+0x4b0><== NOT EXECUTED
a00073cc:	e59b9000 	ldr	r9, [fp]                                      <== NOT EXECUTED
a00073d0:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
a00073d4:	0a00002d 	beq	a0007490 <rtems_termios_open+0xfc>            <== NOT EXECUTED
a00073d8:	e1a04009 	mov	r4, r9                                        <== NOT EXECUTED
a00073dc:	ea000002 	b	a00073ec <rtems_termios_open+0x58>              <== NOT EXECUTED
a00073e0:	e5944000 	ldr	r4, [r4]                                      <== NOT EXECUTED
a00073e4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a00073e8:	0a000028 	beq	a0007490 <rtems_termios_open+0xfc>            <== NOT EXECUTED
    if ((tty->major == major) && (tty->minor == minor))               
a00073ec:	e594300c 	ldr	r3, [r4, #12]                                 <== NOT EXECUTED
a00073f0:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a00073f4:	1afffff9 	bne	a00073e0 <rtems_termios_open+0x4c>            <== NOT EXECUTED
a00073f8:	e5943010 	ldr	r3, [r4, #16]                                 <== NOT EXECUTED
a00073fc:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
a0007400:	1afffff6 	bne	a00073e0 <rtems_termios_open+0x4c>            <== NOT EXECUTED
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
  if (!tty->refcount++) {                                             
a0007404:	e5943008 	ldr	r3, [r4, #8]                                  <== NOT EXECUTED
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
a0007408:	e5981000 	ldr	r1, [r8]                                      <== NOT EXECUTED
  if (!tty->refcount++) {                                             
a000740c:	e2832001 	add	r2, r3, #1                                    <== NOT EXECUTED
a0007410:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
a0007414:	e5814034 	str	r4, [r1, #52]	; 0x34                          <== NOT EXECUTED
  if (!tty->refcount++) {                                             
a0007418:	e5842008 	str	r2, [r4, #8]                                  <== NOT EXECUTED
a000741c:	1a000009 	bne	a0007448 <rtems_termios_open+0xb4>            <== NOT EXECUTED
    if (tty->device.firstOpen)                                        
a0007420:	e5943098 	ldr	r3, [r4, #152]	; 0x98                         <== NOT EXECUTED
a0007424:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007428:	0a000003 	beq	a000743c <rtems_termios_open+0xa8>            <== NOT EXECUTED
      (*tty->device.firstOpen)(major, minor, arg);                    
a000742c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007430:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a0007434:	e1a02008 	mov	r2, r8                                        <== NOT EXECUTED
a0007438:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
a000743c:	e59430b4 	ldr	r3, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a0007440:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0007444:	0a000004 	beq	a000745c <rtems_termios_open+0xc8>            <== NOT EXECUTED
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
a0007448:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a000744c:	eb0009cf 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a0007450:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0007454:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a0007458:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_start(                                          
a000745c:	e59400c4 	ldr	r0, [r4, #196]	; 0xc4                         <== NOT EXECUTED
a0007460:	e59f13e0 	ldr	r1, [pc, #992]	; a0007848 <rtems_termios_open+0x4b4><== NOT EXECUTED
a0007464:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0007468:	eb000a9c 	bl	a0009ee0 <rtems_task_start>                    <== NOT EXECUTED
        tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
a000746c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007470:	1a0000d6 	bne	a00077d0 <rtems_termios_open+0x43c>           <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
a0007474:	e59400c8 	ldr	r0, [r4, #200]	; 0xc8                         <== NOT EXECUTED
a0007478:	e59f13cc 	ldr	r1, [pc, #972]	; a000784c <rtems_termios_open+0x4b8><== NOT EXECUTED
a000747c:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a0007480:	eb000a96 	bl	a0009ee0 <rtems_task_start>                    <== NOT EXECUTED
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
a0007484:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007488:	0affffee 	beq	a0007448 <rtems_termios_open+0xb4>            <== NOT EXECUTED
a000748c:	ea0000cf 	b	a00077d0 <rtems_termios_open+0x43c>             <== NOT EXECUTED
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
a0007490:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0007494:	e3a010e8 	mov	r1, #232	; 0xe8                               <== NOT EXECUTED
a0007498:	ebfffb47 	bl	a00061bc <calloc>                              <== NOT EXECUTED
    if (tty == NULL) {                                                
a000749c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
a00074a0:	e58d0018 	str	r0, [sp, #24]                                 <== NOT EXECUTED
a00074a4:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
    if (tty == NULL) {                                                
a00074a8:	0a0000b3 	beq	a000777c <rtems_termios_open+0x3e8>           <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
a00074ac:	e59f039c 	ldr	r0, [pc, #924]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
a00074b0:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
a00074b4:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
a00074b8:	e5813064 	str	r3, [r1, #100]	; 0x64                         <== NOT EXECUTED
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
a00074bc:	e5910064 	ldr	r0, [r1, #100]	; 0x64                         <== NOT EXECUTED
a00074c0:	ebfffc92 	bl	a0006710 <malloc>                              <== NOT EXECUTED
a00074c4:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
    if (tty->rawInBuf.theBuf == NULL) {                               
a00074c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
a00074cc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
a00074d0:	e5820058 	str	r0, [r2, #88]	; 0x58                          <== NOT EXECUTED
    if (tty->rawInBuf.theBuf == NULL) {                               
a00074d4:	0a0000ac 	beq	a000778c <rtems_termios_open+0x3f8>           <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
a00074d8:	e59fc370 	ldr	ip, [pc, #880]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
a00074dc:	e59de018 	ldr	lr, [sp, #24]                                 <== NOT EXECUTED
a00074e0:	e59c2004 	ldr	r2, [ip, #4]                                  <== NOT EXECUTED
a00074e4:	e58e2088 	str	r2, [lr, #136]	; 0x88                         <== NOT EXECUTED
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
a00074e8:	e59e0088 	ldr	r0, [lr, #136]	; 0x88                         <== NOT EXECUTED
a00074ec:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a00074f0:	ebfffc86 	bl	a0006710 <malloc>                              <== NOT EXECUTED
a00074f4:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
    if (tty->rawOutBuf.theBuf == NULL) {                              
a00074f8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
a00074fc:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
    if (tty->rawOutBuf.theBuf == NULL) {                              
a0007500:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
a0007504:	e580207c 	str	r2, [r0, #124]	; 0x7c                         <== NOT EXECUTED
    if (tty->rawOutBuf.theBuf == NULL) {                              
a0007508:	0a000097 	beq	a000776c <rtems_termios_open+0x3d8>           <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
a000750c:	e59f133c 	ldr	r1, [pc, #828]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
a0007510:	e5910008 	ldr	r0, [r1, #8]                                  <== NOT EXECUTED
a0007514:	e58d2010 	str	r2, [sp, #16]                                 <== NOT EXECUTED
a0007518:	e58d300c 	str	r3, [sp, #12]                                 <== NOT EXECUTED
a000751c:	ebfffc7b 	bl	a0006710 <malloc>                              <== NOT EXECUTED
a0007520:	e59dc018 	ldr	ip, [sp, #24]                                 <== NOT EXECUTED
    if (tty->cbuf == NULL) {                                          
a0007524:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007528:	e59d2010 	ldr	r2, [sp, #16]                                 <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
a000752c:	e58c001c 	str	r0, [ip, #28]                                 <== NOT EXECUTED
    if (tty->cbuf == NULL) {                                          
a0007530:	0a00008a 	beq	a0007760 <rtems_termios_open+0x3cc>           <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * Initialize wakeup callbacks                                    
     */                                                               
    tty->tty_snd.sw_pfn = NULL;                                       
a0007534:	e59de018 	ldr	lr, [sp, #24]                                 <== NOT EXECUTED
a0007538:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
a000753c:	e1590003 	cmp	r9, r3                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
a0007540:	e58e3004 	str	r3, [lr, #4]                                  <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * Initialize wakeup callbacks                                    
     */                                                               
    tty->tty_snd.sw_pfn = NULL;                                       
a0007544:	e58e30d4 	str	r3, [lr, #212]	; 0xd4                         <== NOT EXECUTED
    tty->tty_snd.sw_arg = NULL;                                       
a0007548:	e58e30d8 	str	r3, [lr, #216]	; 0xd8                         <== NOT EXECUTED
    tty->tty_rcv.sw_pfn = NULL;                                       
a000754c:	e58e30dc 	str	r3, [lr, #220]	; 0xdc                         <== NOT EXECUTED
    tty->tty_rcv.sw_arg = NULL;                                       
a0007550:	e58e30e0 	str	r3, [lr, #224]	; 0xe0                         <== NOT EXECUTED
    tty->tty_rcvwakeup  = 0;                                          
a0007554:	e58e30e4 	str	r3, [lr, #228]	; 0xe4                         <== NOT EXECUTED
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
a0007558:	e59f32f4 	ldr	r3, [pc, #756]	; a0007854 <rtems_termios_open+0x4c0><== NOT EXECUTED
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
a000755c:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
a0007560:	e59f12e8 	ldr	r1, [pc, #744]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
a0007564:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
      rtems_termios_ttyHead->back = tty;                              
a0007568:	1589e004 	strne	lr, [r9, #4]                                <== NOT EXECUTED
    rtems_termios_ttyHead = tty;                                      
a000756c:	e58b0000 	str	r0, [fp]                                      <== NOT EXECUTED
    if (rtems_termios_ttyTail == NULL)                                
a0007570:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
      rtems_termios_ttyTail = tty;                                    
a0007574:	05830000 	streq	r0, [r3]                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
a0007578:	e5d1000c 	ldrb	r0, [r1, #12]                                <== NOT EXECUTED
    tty->tty_rcvwakeup  = 0;                                          
                                                                      
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
a000757c:	e58e9000 	str	r9, [lr]                                      <== NOT EXECUTED
    tty->major = major;                                               
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
a0007580:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
      rtems_termios_ttyTail = tty;                                    
                                                                      
    tty->minor = minor;                                               
a0007584:	e59d9018 	ldr	r9, [sp, #24]                                 <== NOT EXECUTED
    tty->major = major;                                               
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
a0007588:	e3800315 	orr	r0, r0, #1409286144	; 0x54000000              <== NOT EXECUTED
a000758c:	e3800852 	orr	r0, r0, #5373952	; 0x520000                   <== NOT EXECUTED
a0007590:	e282c014 	add	ip, r2, #20                                   <== NOT EXECUTED
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
      rtems_termios_ttyTail = tty;                                    
                                                                      
    tty->minor = minor;                                               
a0007594:	e5896010 	str	r6, [r9, #16]                                 <== NOT EXECUTED
    tty->major = major;                                               
a0007598:	e589500c 	str	r5, [r9, #12]                                 <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
a000759c:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a00075a0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00075a4:	e3800c69 	orr	r0, r0, #26880	; 0x6900                       <== NOT EXECUTED
a00075a8:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
a00075ac:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00075b0:	eb000893 	bl	a0009804 <rtems_semaphore_create>              <== NOT EXECUTED
      rtems_build_name ('T', 'R', 'i', c),                            
      1,                                                              
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->isem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
a00075b4:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
a00075b8:	e59f9290 	ldr	r9, [pc, #656]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
      1,                                                              
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->isem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
a00075bc:	1a000083 	bne	a00077d0 <rtems_termios_open+0x43c>           <== NOT EXECUTED
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'o', c),                            
a00075c0:	e5d9000c 	ldrb	r0, [r9, #12]                                <== NOT EXECUTED
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->isem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
a00075c4:	e59de018 	ldr	lr, [sp, #24]                                 <== NOT EXECUTED
a00075c8:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a00075cc:	e3800315 	orr	r0, r0, #1409286144	; 0x54000000              <== NOT EXECUTED
a00075d0:	e3800852 	orr	r0, r0, #5373952	; 0x520000                   <== NOT EXECUTED
a00075d4:	e28ec018 	add	ip, lr, #24                                   <== NOT EXECUTED
a00075d8:	e3800c6f 	orr	r0, r0, #28416	; 0x6f00                       <== NOT EXECUTED
a00075dc:	e3a02054 	mov	r2, #84	; 0x54                                <== NOT EXECUTED
a00075e0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00075e4:	eb000886 	bl	a0009804 <rtems_semaphore_create>              <== NOT EXECUTED
      rtems_build_name ('T', 'R', 'o', c),                            
      1,                                                              
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->osem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
a00075e8:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a00075ec:	1a000077 	bne	a00077d0 <rtems_termios_open+0x43c>           <== NOT EXECUTED
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'x', c),                            
a00075f0:	e5d9000c 	ldrb	r0, [r9, #12]                                <== NOT EXECUTED
      RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
      RTEMS_NO_PRIORITY,                                              
      &tty->osem);                                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
a00075f4:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
a00075f8:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a00075fc:	e3800315 	orr	r0, r0, #1409286144	; 0x54000000              <== NOT EXECUTED
a0007600:	e3800852 	orr	r0, r0, #5373952	; 0x520000                   <== NOT EXECUTED
a0007604:	e282c08c 	add	ip, r2, #140	; 0x8c                           <== NOT EXECUTED
a0007608:	e3800b1e 	orr	r0, r0, #30720	; 0x7800                       <== NOT EXECUTED
a000760c:	e3a02020 	mov	r2, #32                                       <== NOT EXECUTED
a0007610:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a0007614:	eb00087a 	bl	a0009804 <rtems_semaphore_create>              <== NOT EXECUTED
      rtems_build_name ('T', 'R', 'x', c),                            
      0,                                                              
      RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,                     
      RTEMS_NO_PRIORITY,                                              
      &tty->rawOutBuf.Semaphore);                                     
    if (sc != RTEMS_SUCCESSFUL)                                       
a0007618:	e250b000 	subs	fp, r0, #0                                   <== NOT EXECUTED
a000761c:	1a00006b 	bne	a00077d0 <rtems_termios_open+0x43c>           <== NOT EXECUTED
    tty->rawOutBufState = rob_idle;                                   
                                                                      
    /*                                                                
     * Set callbacks                                                  
     */                                                               
    tty->device = *callbacks;                                         
a0007620:	e59d3018 	ldr	r3, [sp, #24]                                 <== NOT EXECUTED
a0007624:	e59dc014 	ldr	ip, [sp, #20]                                 <== NOT EXECUTED
a0007628:	e283e098 	add	lr, r3, #152	; 0x98                           <== NOT EXECUTED
a000762c:	e8bc000f 	ldm	ip!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a0007630:	e8ae000f 	stmia	lr!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a0007634:	e89c000f 	ldm	ip, {r0, r1, r2, r3}                          <== NOT EXECUTED
a0007638:	e88e000f 	stm	lr, {r0, r1, r2, r3}                          <== NOT EXECUTED
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
a000763c:	e59dc018 	ldr	ip, [sp, #24]                                 <== NOT EXECUTED
a0007640:	e59c30b4 	ldr	r3, [ip, #180]	; 0xb4                         <== NOT EXECUTED
      RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,                     
      RTEMS_NO_PRIORITY,                                              
      &tty->rawOutBuf.Semaphore);                                     
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_fatal_error_occurred (sc);                                
    tty->rawOutBufState = rob_idle;                                   
a0007644:	e58cb094 	str	fp, [ip, #148]	; 0x94                         <== NOT EXECUTED
    tty->device = *callbacks;                                         
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
a0007648:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a000764c:	0a000060 	beq	a00077d4 <rtems_termios_open+0x440>           <== NOT EXECUTED
           &tty->rxTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
a0007650:	e59d2018 	ldr	r2, [sp, #24]                                 <== NOT EXECUTED
a0007654:	e59230a0 	ldr	r3, [r2, #160]	; 0xa0                         <== NOT EXECUTED
a0007658:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000765c:	0a00004d 	beq	a0007798 <rtems_termios_open+0x404>           <== NOT EXECUTED
a0007660:	e59230b4 	ldr	r3, [r2, #180]	; 0xb4                         <== NOT EXECUTED
a0007664:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0007668:	0a00004a 	beq	a0007798 <rtems_termios_open+0x404>           <== NOT EXECUTED
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
    tty->termios.c_cc[VLNEXT] = '\026';                               
                                                                      
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
a000766c:	e59dc018 	ldr	ip, [sp, #24]                                 <== NOT EXECUTED
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
    tty->termios.c_cc[VEOF] = '\004';                                 
    tty->termios.c_cc[VEOL] = '\000';                                 
a0007670:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a0007674:	e59f01d4 	ldr	r0, [pc, #468]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
    tty->termios.c_cc[VLNEXT] = '\026';                               
                                                                      
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
a0007678:	e58c30b8 	str	r3, [ip, #184]	; 0xb8                         <== NOT EXECUTED
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
a000767c:	e59c9064 	ldr	r9, [ip, #100]	; 0x64                         <== NOT EXECUTED
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a0007680:	e5d0e00c 	ldrb	lr, [r0, #12]                                <== NOT EXECUTED
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
a0007684:	e3a02c82 	mov	r2, #33280	; 0x8200                           <== NOT EXECUTED
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
a0007688:	e1a090a9 	lsr	r9, r9, #1                                    <== NOT EXECUTED
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a000768c:	e35e007a 	cmp	lr, #122	; 0x7a                               <== NOT EXECUTED
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
a0007690:	e58d9008 	str	r9, [sp, #8]                                  <== NOT EXECUTED
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a0007694:	e28e9001 	add	r9, lr, #1                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
a0007698:	e59de018 	ldr	lr, [sp, #24]                                 <== NOT EXECUTED
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
a000769c:	e282203b 	add	r2, r2, #59	; 0x3b                            <== NOT EXECUTED
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
a00076a0:	e59cb064 	ldr	fp, [ip, #100]	; 0x64                         <== NOT EXECUTED
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
    tty->termios.c_cc[VEOF] = '\004';                                 
    tty->termios.c_cc[VEOL] = '\000';                                 
a00076a4:	e5ce304c 	strb	r3, [lr, #76]	; 0x4c                         <== NOT EXECUTED
    tty->termios.c_cc[VEOL2] = '\000';                                
a00076a8:	e5ce3051 	strb	r3, [lr, #81]	; 0x51                         <== NOT EXECUTED
    tty->termios.c_cc[VSTART] = '\021';                               
a00076ac:	e3a03011 	mov	r3, #17                                       <== NOT EXECUTED
a00076b0:	e5ce3049 	strb	r3, [lr, #73]	; 0x49                         <== NOT EXECUTED
    tty->termios.c_cc[VSTOP] = '\023';                                
a00076b4:	e3a03013 	mov	r3, #19                                       <== NOT EXECUTED
a00076b8:	e5ce304a 	strb	r3, [lr, #74]	; 0x4a                         <== NOT EXECUTED
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
a00076bc:	e58e203c 	str	r2, [lr, #60]	; 0x3c                          <== NOT EXECUTED
    tty->termios.c_cc[VEOF] = '\004';                                 
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
a00076c0:	e3a0301a 	mov	r3, #26                                       <== NOT EXECUTED
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
a00076c4:	e3a02003 	mov	r2, #3                                        <== NOT EXECUTED
a00076c8:	e5ce2041 	strb	r2, [lr, #65]	; 0x41                         <== NOT EXECUTED
    tty->termios.c_cc[VEOF] = '\004';                                 
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
a00076cc:	e5ce304b 	strb	r3, [lr, #75]	; 0x4b                         <== NOT EXECUTED
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
a00076d0:	e3a0201c 	mov	r2, #28                                       <== NOT EXECUTED
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
a00076d4:	e3a03012 	mov	r3, #18                                       <== NOT EXECUTED
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
    tty->termios.c_lflag =                                            
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
a00076d8:	e5ce2042 	strb	r2, [lr, #66]	; 0x42                         <== NOT EXECUTED
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
a00076dc:	e5ce304d 	strb	r3, [lr, #77]	; 0x4d                         <== NOT EXECUTED
    tty->termios.c_lflag =                                            
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
a00076e0:	e3a0207f 	mov	r2, #127	; 0x7f                               <== NOT EXECUTED
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
a00076e4:	e3a0300f 	mov	r3, #15                                       <== NOT EXECUTED
    tty->termios.c_lflag =                                            
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
a00076e8:	e5ce2043 	strb	r2, [lr, #67]	; 0x43                         <== NOT EXECUTED
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
a00076ec:	e5ce304e 	strb	r3, [lr, #78]	; 0x4e                         <== NOT EXECUTED
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
a00076f0:	e3a02015 	mov	r2, #21                                       <== NOT EXECUTED
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
a00076f4:	e3a03017 	mov	r3, #23                                       <== NOT EXECUTED
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
a00076f8:	e3a01e8b 	mov	r1, #2224	; 0x8b0                             <== NOT EXECUTED
a00076fc:	e281100d 	add	r1, r1, #13                                   <== NOT EXECUTED
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
a0007700:	e5ce2044 	strb	r2, [lr, #68]	; 0x44                         <== NOT EXECUTED
    tty->termios.c_cc[VSTART] = '\021';                               
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
a0007704:	e5ce304f 	strb	r3, [lr, #79]	; 0x4f                         <== NOT EXECUTED
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
    tty->termios.c_cc[VEOF] = '\004';                                 
a0007708:	e3a02004 	mov	r2, #4                                        <== NOT EXECUTED
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
    tty->termios.c_cc[VLNEXT] = '\026';                               
a000770c:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
a0007710:	e3a00b06 	mov	r0, #6144	; 0x1800                            <== NOT EXECUTED
a0007714:	e2800005 	add	r0, r0, #5                                    <== NOT EXECUTED
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
    tty->termios.c_cc[VQUIT] = '\034';                                
    tty->termios.c_cc[VERASE] = '\177';                               
    tty->termios.c_cc[VKILL] = '\025';                                
    tty->termios.c_cc[VEOF] = '\004';                                 
a0007718:	e5ce2045 	strb	r2, [lr, #69]	; 0x45                         <== NOT EXECUTED
    tty->termios.c_cc[VSTOP] = '\023';                                
    tty->termios.c_cc[VSUSP] = '\032';                                
    tty->termios.c_cc[VREPRINT] = '\022';                             
    tty->termios.c_cc[VDISCARD] = '\017';                             
    tty->termios.c_cc[VWERASE] = '\027';                              
    tty->termios.c_cc[VLNEXT] = '\026';                               
a000771c:	e5ce3050 	strb	r3, [lr, #80]	; 0x50                         <== NOT EXECUTED
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
a0007720:	e58e1038 	str	r1, [lr, #56]	; 0x38                          <== NOT EXECUTED
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a0007724:	e59f1124 	ldr	r1, [pc, #292]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
a0007728:	e08bb08b 	add	fp, fp, fp, lsl #1                            <== NOT EXECUTED
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
a000772c:	e58e0034 	str	r0, [lr, #52]	; 0x34                          <== NOT EXECUTED
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
a0007730:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
a0007734:	e3a0cc25 	mov	ip, #9472	; 0x2500                            <== NOT EXECUTED
a0007738:	e28cc002 	add	ip, ip, #2                                    <== NOT EXECUTED
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
a000773c:	e1a0b12b 	lsr	fp, fp, #2                                    <== NOT EXECUTED
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
a0007740:	0282205d 	addeq	r2, r2, #93	; 0x5d                          <== NOT EXECUTED
a0007744:	01a03001 	moveq	r3, r1                                      <== NOT EXECUTED
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
a0007748:	e5c1900c 	strb	r9, [r1, #12]                                <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
a000774c:	e58ec030 	str	ip, [lr, #48]	; 0x30                          <== NOT EXECUTED
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
a0007750:	e58e00bc 	str	r0, [lr, #188]	; 0xbc                         <== NOT EXECUTED
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
a0007754:	e58eb0c0 	str	fp, [lr, #192]	; 0xc0                         <== NOT EXECUTED
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
a0007758:	05c3200c 	strbeq	r2, [r3, #12]                              <== NOT EXECUTED
a000775c:	eaffff28 	b	a0007404 <rtems_termios_open+0x70>              <== NOT EXECUTED
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
    if (tty->cbuf == NULL) {                                          
            free((void *)(tty->rawOutBuf.theBuf));                    
a0007760:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0007764:	ebfffb02 	bl	a0006374 <free>                                <== NOT EXECUTED
            free((void *)(tty->rawInBuf.theBuf));                     
a0007768:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a000776c:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0007770:	ebfffaff 	bl	a0006374 <free>                                <== NOT EXECUTED
            free(tty);                                                
a0007774:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
a0007778:	ebfffafd 	bl	a0006374 <free>                                <== NOT EXECUTED
      rtems_semaphore_release (rtems_termios_ttyMutex);               
a000777c:	e5970000 	ldr	r0, [r7]                                      <== NOT EXECUTED
a0007780:	eb000902 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                         
a0007784:	e3a0a01a 	mov	sl, #26                                       <== NOT EXECUTED
a0007788:	eaffff30 	b	a0007450 <rtems_termios_open+0xbc>              <== NOT EXECUTED
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
    if (tty->rawInBuf.theBuf == NULL) {                               
            free(tty);                                                
a000778c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a0007790:	ebfffaf7 	bl	a0006374 <free>                                <== NOT EXECUTED
a0007794:	eafffff8 	b	a000777c <rtems_termios_open+0x3e8>             <== NOT EXECUTED
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
        rtems_build_name ('T', 'R', 'r', c),                          
a0007798:	e59f30b0 	ldr	r3, [pc, #176]	; a0007850 <rtems_termios_open+0x4bc><== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
a000779c:	e59d9018 	ldr	r9, [sp, #24]                                 <== NOT EXECUTED
a00077a0:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
        rtems_build_name ('T', 'R', 'r', c),                          
a00077a4:	e5d3000c 	ldrb	r0, [r3, #12]                                <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
a00077a8:	e289c068 	add	ip, r9, #104	; 0x68                           <== NOT EXECUTED
a00077ac:	e3a02024 	mov	r2, #36	; 0x24                                <== NOT EXECUTED
a00077b0:	e3800315 	orr	r0, r0, #1409286144	; 0x54000000              <== NOT EXECUTED
a00077b4:	e3800852 	orr	r0, r0, #5373952	; 0x520000                   <== NOT EXECUTED
a00077b8:	e3800c72 	orr	r0, r0, #29184	; 0x7200                       <== NOT EXECUTED
a00077bc:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a00077c0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a00077c4:	eb00080e 	bl	a0009804 <rtems_semaphore_create>              <== NOT EXECUTED
        rtems_build_name ('T', 'R', 'r', c),                          
        0,                                                            
        RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,               
        RTEMS_NO_PRIORITY,                                            
        &tty->rawInBuf.Semaphore);                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
a00077c8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00077cc:	0affffa6 	beq	a000766c <rtems_termios_open+0x2d8>           <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
a00077d0:	eb000a4c 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_create (                                        
                                   rtems_build_name ('T', 'x', 'T', c),
a00077d4:	e5d9000c 	ldrb	r0, [r9, #12]                                <== NOT EXECUTED
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_create (                                        
a00077d8:	e28cc0c8 	add	ip, ip, #200	; 0xc8                           <== NOT EXECUTED
a00077dc:	e3a0100a 	mov	r1, #10                                       <== NOT EXECUTED
a00077e0:	e3800315 	orr	r0, r0, #1409286144	; 0x54000000              <== NOT EXECUTED
a00077e4:	e380071e 	orr	r0, r0, #7864320	; 0x780000                   <== NOT EXECUTED
a00077e8:	e3800b15 	orr	r0, r0, #21504	; 0x5400                       <== NOT EXECUTED
a00077ec:	e3a02b01 	mov	r2, #1024	; 0x400                             <== NOT EXECUTED
a00077f0:	e3a03c05 	mov	r3, #1280	; 0x500                             <== NOT EXECUTED
a00077f4:	e88d1800 	stm	sp, {fp, ip}                                  <== NOT EXECUTED
a00077f8:	eb00090e 	bl	a0009c38 <rtems_task_create>                   <== NOT EXECUTED
           TERMIOS_TXTASK_STACKSIZE,                                  
           RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                    
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->txTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
a00077fc:	e250e000 	subs	lr, r0, #0                                   <== NOT EXECUTED
a0007800:	1afffff2 	bne	a00077d0 <rtems_termios_open+0x43c>           <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
                                   rtems_build_name ('R', 'x', 'T', c),
a0007804:	e5d9000c 	ldrb	r0, [r9, #12]                                <== NOT EXECUTED
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->txTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
a0007808:	e59d1018 	ldr	r1, [sp, #24]                                 <== NOT EXECUTED
a000780c:	e3a02b01 	mov	r2, #1024	; 0x400                             <== NOT EXECUTED
a0007810:	e3800452 	orr	r0, r0, #1375731712	; 0x52000000              <== NOT EXECUTED
a0007814:	e380071e 	orr	r0, r0, #7864320	; 0x780000                   <== NOT EXECUTED
a0007818:	e281c0c4 	add	ip, r1, #196	; 0xc4                           <== NOT EXECUTED
a000781c:	e3800b15 	orr	r0, r0, #21504	; 0x5400                       <== NOT EXECUTED
a0007820:	e3a01009 	mov	r1, #9                                        <== NOT EXECUTED
a0007824:	e3a03c05 	mov	r3, #1280	; 0x500                             <== NOT EXECUTED
a0007828:	e58de000 	str	lr, [sp]                                      <== NOT EXECUTED
a000782c:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a0007830:	eb000900 	bl	a0009c38 <rtems_task_create>                   <== NOT EXECUTED
           TERMIOS_RXTASK_STACKSIZE,                                  
           RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |                    
           RTEMS_NO_ASR,                                              
           RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,                     
           &tty->rxTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
a0007834:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007838:	0affff84 	beq	a0007650 <rtems_termios_open+0x2bc>           <== NOT EXECUTED
a000783c:	eaffffe3 	b	a00077d0 <rtems_termios_open+0x43c>             <== NOT EXECUTED
                                                                      

a0007de8 <rtems_termios_puts>: const unsigned char *buf = _buf; unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
a0007de8:	e59230b4 	ldr	r3, [r2, #180]	; 0xb4                         <== NOT EXECUTED
 * Send characters to device-specific code                            
 */                                                                   
void                                                                  
rtems_termios_puts (                                                  
  const void *_buf, int len, struct rtems_termios_tty *tty)           
{                                                                     
a0007dec:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  const unsigned char *buf = _buf;                                    
  unsigned int newHead;                                               
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
a0007df0:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
 * Send characters to device-specific code                            
 */                                                                   
void                                                                  
rtems_termios_puts (                                                  
  const void *_buf, int len, struct rtems_termios_tty *tty)           
{                                                                     
a0007df4:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a0007df8:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a0007dfc:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  const unsigned char *buf = _buf;                                    
  unsigned int newHead;                                               
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
a0007e00:	0a000037 	beq	a0007ee4 <rtems_termios_puts+0xfc>            <== NOT EXECUTED
    (*tty->device.write)(tty->minor, (void *)buf, len);               
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
  while (len) {                                                       
a0007e04:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, (void *)buf, len);               
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
a0007e08:	e5926080 	ldr	r6, [r2, #128]	; 0x80                         <== NOT EXECUTED
  while (len) {                                                       
a0007e0c:	0a00002b 	beq	a0007ec0 <rtems_termios_puts+0xd8>            <== NOT EXECUTED
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
      tty->rawOutBufState = rob_wait;                                 
a0007e10:	e3a05002 	mov	r5, #2                                        <== NOT EXECUTED
      (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);         
      } else {                                                        
        /* remember that output has been stopped due to flow ctrl*/   
        tty->flow_ctrl |= FL_OSTOP;                                   
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
a0007e14:	e3a0b001 	mov	fp, #1                                        <== NOT EXECUTED
     *  len -= ncopy                                                  
     *                                                                
     * To minimize latency, the memcpy should be done                 
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
a0007e18:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
a0007e1c:	e2860001 	add	r0, r6, #1                                    <== NOT EXECUTED
a0007e20:	eb0032b7 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
a0007e24:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0007e28:	e10fa000 	mrs	sl, CPSR                                      <== NOT EXECUTED
a0007e2c:	e38a3080 	orr	r3, sl, #128	; 0x80                           <== NOT EXECUTED
a0007e30:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
a0007e34:	e5949084 	ldr	r9, [r4, #132]	; 0x84                         <== NOT EXECUTED
a0007e38:	e1590000 	cmp	r9, r0                                        <== NOT EXECUTED
a0007e3c:	1a00000d 	bne	a0007e78 <rtems_termios_puts+0x90>            <== NOT EXECUTED
      tty->rawOutBufState = rob_wait;                                 
a0007e40:	e5845094 	str	r5, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0007e44:	e129f00a 	msr	CPSR_fc, sl                                   <== NOT EXECUTED
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
a0007e48:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0007e4c:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
a0007e50:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0007e54:	eb000704 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
a0007e58:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0007e5c:	1a000026 	bne	a0007efc <rtems_termios_puts+0x114>           <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0007e60:	e10fa000 	mrs	sl, CPSR                                      <== NOT EXECUTED
a0007e64:	e38a3080 	orr	r3, sl, #128	; 0x80                           <== NOT EXECUTED
a0007e68:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
     * To minimize latency, the memcpy should be done                 
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
a0007e6c:	e5943084 	ldr	r3, [r4, #132]	; 0x84                         <== NOT EXECUTED
a0007e70:	e1530009 	cmp	r3, r9                                        <== NOT EXECUTED
a0007e74:	0afffff1 	beq	a0007e40 <rtems_termios_puts+0x58>            <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
    }                                                                 
    tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;              
a0007e78:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
a0007e7c:	e4d81001 	ldrb	r1, [r8], #1                                 <== NOT EXECUTED
a0007e80:	e594207c 	ldr	r2, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a0007e84:	e7c21003 	strb	r1, [r2, r3]                                 <== NOT EXECUTED
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
a0007e88:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
    }                                                                 
    tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;              
    tty->rawOutBuf.Head = newHead;                                    
a0007e8c:	e5846080 	str	r6, [r4, #128]	; 0x80                         <== NOT EXECUTED
    if (tty->rawOutBufState == rob_idle) {                            
a0007e90:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0007e94:	1a000006 	bne	a0007eb4 <rtems_termios_puts+0xcc>            <== NOT EXECUTED
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
a0007e98:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0007e9c:	e3130010 	tst	r3, #16                                       <== NOT EXECUTED
a0007ea0:	0a000007 	beq	a0007ec4 <rtems_termios_puts+0xdc>            <== NOT EXECUTED
        (*tty->device.write)(tty->minor,                              
      (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);         
      } else {                                                        
        /* remember that output has been stopped due to flow ctrl*/   
        tty->flow_ctrl |= FL_OSTOP;                                   
a0007ea4:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0007ea8:	e3833020 	orr	r3, r3, #32                                   <== NOT EXECUTED
a0007eac:	e58430b8 	str	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
a0007eb0:	e584b094 	str	fp, [r4, #148]	; 0x94                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0007eb4:	e129f00a 	msr	CPSR_fc, sl                                   <== NOT EXECUTED
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, (void *)buf, len);               
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
  while (len) {                                                       
a0007eb8:	e2577001 	subs	r7, r7, #1                                   <== NOT EXECUTED
a0007ebc:	1affffd5 	bne	a0007e18 <rtems_termios_puts+0x30>            <== NOT EXECUTED
a0007ec0:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
        (*tty->device.write)(tty->minor,                              
      (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);         
a0007ec4:	e5942084 	ldr	r2, [r4, #132]	; 0x84                         <== NOT EXECUTED
    tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;              
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
        (*tty->device.write)(tty->minor,                              
a0007ec8:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a0007ecc:	e59430a4 	ldr	r3, [r4, #164]	; 0xa4                         <== NOT EXECUTED
a0007ed0:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0007ed4:	e0811002 	add	r1, r1, r2                                    <== NOT EXECUTED
a0007ed8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0007edc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0007ee0:	eafffff2 	b	a0007eb0 <rtems_termios_puts+0xc8>              <== NOT EXECUTED
  unsigned int newHead;                                               
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, (void *)buf, len);               
a0007ee4:	e59230a4 	ldr	r3, [r2, #164]	; 0xa4                         <== NOT EXECUTED
a0007ee8:	e5920010 	ldr	r0, [r2, #16]                                 <== NOT EXECUTED
a0007eec:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a0007ef0:	e1a02007 	mov	r2, r7                                        <== NOT EXECUTED
a0007ef4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    return;                                                           
a0007ef8:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
      tty->rawOutBufState = rob_wait;                                 
      rtems_interrupt_enable (level);                                 
      sc = rtems_semaphore_obtain(                                    
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
a0007efc:	eb000881 	bl	a000a108 <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a0008618 <rtems_termios_read>: rtems_status_code rtems_termios_read (void *arg) { rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
a0008618:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
a000861c:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
a0008620:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0008624:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
a0008628:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
  uint32_t   count = args->count;                                     
a000862c:	e5908010 	ldr	r8, [r0, #16]                                 <== NOT EXECUTED
  char      *buffer = args->buffer;                                   
a0008630:	e590a00c 	ldr	sl, [r0, #12]                                 <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
a0008634:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
  struct rtems_termios_tty *tty = args->iop->data1;                   
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0008638:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a000863c:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a0008640:	eb000509 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
a0008644:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008648:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
a000864c:	1a00000d 	bne	a0008688 <rtems_termios_read+0x70>            <== NOT EXECUTED
    return sc;                                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_read != NULL) {             
a0008650:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         <== NOT EXECUTED
a0008654:	e59f3364 	ldr	r3, [pc, #868]	; a00089c0 <rtems_termios_read+0x3a8><== NOT EXECUTED
a0008658:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
a000865c:	e5933008 	ldr	r3, [r3, #8]                                  <== NOT EXECUTED
a0008660:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008664:	0a00000a 	beq	a0008694 <rtems_termios_read+0x7c>            <== NOT EXECUTED
    sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);          
a0008668:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000866c:	e1a01009 	mov	r1, r9                                        <== NOT EXECUTED
a0008670:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    tty->tty_rcvwakeup = 0;                                           
a0008674:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_read != NULL) {             
    sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);          
a0008678:	e58d0000 	str	r0, [sp]                                      <== NOT EXECUTED
    tty->tty_rcvwakeup = 0;                                           
a000867c:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
    rtems_semaphore_release (tty->isem);                              
a0008680:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a0008684:	eb000541 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
  args->bytes_moved = args->count - count;                            
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
  return sc;                                                          
}                                                                     
a0008688:	e59d0000 	ldr	r0, [sp]                                      <== NOT EXECUTED
a000868c:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a0008690:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
a0008694:	e5942024 	ldr	r2, [r4, #36]	; 0x24                          <== NOT EXECUTED
a0008698:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a000869c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a00086a0:	0a000018 	beq	a0008708 <rtems_termios_read+0xf0>            <== NOT EXECUTED
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
a00086a4:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a00086a8:	0a00000e 	beq	a00086e8 <rtems_termios_read+0xd0>            <== NOT EXECUTED
a00086ac:	e5943024 	ldr	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
a00086b0:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
a00086b4:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
a00086b8:	ba000003 	blt	a00086cc <rtems_termios_read+0xb4>            <== NOT EXECUTED
a00086bc:	ea000009 	b	a00086e8 <rtems_termios_read+0xd0>              <== NOT EXECUTED
a00086c0:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
a00086c4:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a00086c8:	da000006 	ble	a00086e8 <rtems_termios_read+0xd0>            <== NOT EXECUTED
    *buffer++ = tty->cbuf[tty->cindex++];                             
a00086cc:	e594201c 	ldr	r2, [r4, #28]                                 <== NOT EXECUTED
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
a00086d0:	e2588001 	subs	r8, r8, #1                                   <== NOT EXECUTED
    *buffer++ = tty->cbuf[tty->cindex++];                             
a00086d4:	e7d22003 	ldrb	r2, [r2, r3]                                 <== NOT EXECUTED
a00086d8:	e2833001 	add	r3, r3, #1                                    <== NOT EXECUTED
a00086dc:	e4ca2001 	strb	r2, [sl], #1                                 <== NOT EXECUTED
a00086e0:	e5843024 	str	r3, [r4, #36]	; 0x24                          <== NOT EXECUTED
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
a00086e4:	1afffff5 	bne	a00086c0 <rtems_termios_read+0xa8>            <== NOT EXECUTED
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
a00086e8:	e5993010 	ldr	r3, [r9, #16]                                 <== NOT EXECUTED
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
a00086ec:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
a00086f0:	e0688003 	rsb	r8, r8, r3                                    <== NOT EXECUTED
  tty->tty_rcvwakeup = 0;                                             
a00086f4:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
a00086f8:	e5898018 	str	r8, [r9, #24]                                 <== NOT EXECUTED
  tty->tty_rcvwakeup = 0;                                             
a00086fc:	e58430e4 	str	r3, [r4, #228]	; 0xe4                         <== NOT EXECUTED
  rtems_semaphore_release (tty->isem);                                
a0008700:	eb000522 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  return sc;                                                          
a0008704:	eaffffdf 	b	a0008688 <rtems_termios_read+0x70>              <== NOT EXECUTED
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
    tty->read_start_column = tty->column;                             
    if (tty->device.pollRead != NULL &&                               
a0008708:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
a000870c:	e59d1000 	ldr	r1, [sp]                                      <== NOT EXECUTED
    tty->read_start_column = tty->column;                             
a0008710:	e5942028 	ldr	r2, [r4, #40]	; 0x28                          <== NOT EXECUTED
    if (tty->device.pollRead != NULL &&                               
a0008714:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
a0008718:	e5841020 	str	r1, [r4, #32]                                 <== NOT EXECUTED
a000871c:	e5841024 	str	r1, [r4, #36]	; 0x24                          <== NOT EXECUTED
    tty->read_start_column = tty->column;                             
a0008720:	e584202c 	str	r2, [r4, #44]	; 0x2c                          <== NOT EXECUTED
    if (tty->device.pollRead != NULL &&                               
a0008724:	0a000002 	beq	a0008734 <rtems_termios_read+0x11c>           <== NOT EXECUTED
a0008728:	e59420b4 	ldr	r2, [r4, #180]	; 0xb4                         <== NOT EXECUTED
a000872c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0008730:	0a000067 	beq	a00088d4 <rtems_termios_read+0x2bc>           <== NOT EXECUTED
 * Fill the input buffer from the raw input queue                     
 */                                                                   
static rtems_status_code                                              
fillBufferQueue (struct rtems_termios_tty *tty)                       
{                                                                     
  rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;        
a0008734:	e5946074 	ldr	r6, [r4, #116]	; 0x74                         <== NOT EXECUTED
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
                       (tty->ccount < (CBUFSIZE-1))) {                
a0008738:	e59f7284 	ldr	r7, [pc, #644]	; a00089c4 <rtems_termios_read+0x3ac><== NOT EXECUTED
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
a000873c:	e3a0bc02 	mov	fp, #512	; 0x200                              <== NOT EXECUTED
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
a0008740:	e2843049 	add	r3, r4, #73	; 0x49                            <== NOT EXECUTED
static rtems_status_code                                              
fillBufferQueue (struct rtems_termios_tty *tty)                       
{                                                                     
  rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;        
  rtems_status_code sc;                                               
  int               wait = (int)1;                                    
a0008744:	e3a05001 	mov	r5, #1                                        <== NOT EXECUTED
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
a0008748:	e28bb002 	add	fp, fp, #2                                    <== NOT EXECUTED
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
a000874c:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a0008750:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0008754:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
a0008758:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000875c:	0a000047 	beq	a0008880 <rtems_termios_read+0x268>           <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
a0008760:	e5972008 	ldr	r2, [r7, #8]                                  <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a0008764:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
a0008768:	e2422001 	sub	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a000876c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0008770:	ca00000f 	bgt	a00087b4 <rtems_termios_read+0x19c>           <== NOT EXECUTED
a0008774:	ea000041 	b	a0008880 <rtems_termios_read+0x268>             <== NOT EXECUTED
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
        if (siproc (c, tty))                                          
a0008778:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000877c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008780:	ebffff5a 	bl	a00084f0 <siproc>                              <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a0008784:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0008788:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
        if (siproc (c, tty))                                          
          wait = 0;                                                   
a000878c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008790:	13a05000 	movne	r5, #0                                      <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a0008794:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
      } else {                                                        
        siproc (c, tty);                                              
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
          wait = 0;                                                   
      }                                                               
      timeout = tty->rawInBufSemaphoreTimeout;                        
a0008798:	e5946070 	ldr	r6, [r4, #112]	; 0x70                         <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a000879c:	0a000037 	beq	a0008880 <rtems_termios_read+0x268>           <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
a00087a0:	e5973008 	ldr	r3, [r7, #8]                                  <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a00087a4:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
a00087a8:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a00087ac:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a00087b0:	aa000032 	bge	a0008880 <rtems_termios_read+0x268>           <== NOT EXECUTED
                       (tty->ccount < (CBUFSIZE-1))) {                
      unsigned char c;                                                
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
a00087b4:	e594005c 	ldr	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a00087b8:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
a00087bc:	e2800001 	add	r0, r0, #1                                    <== NOT EXECUTED
a00087c0:	eb00304f 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
      c = tty->rawInBuf.theBuf[newHead];                              
a00087c4:	e5943058 	ldr	r3, [r4, #88]	; 0x58                          <== NOT EXECUTED
a00087c8:	e7d36000 	ldrb	r6, [r3, r0]                                 <== NOT EXECUTED
      tty->rawInBuf.Head = newHead;                                   
a00087cc:	e584005c 	str	r0, [r4, #92]	; 0x5c                          <== NOT EXECUTED
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
a00087d0:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
a00087d4:	e5942064 	ldr	r2, [r4, #100]	; 0x64                         <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
a00087d8:	e5941064 	ldr	r1, [r4, #100]	; 0x64                         <== NOT EXECUTED
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
      c = tty->rawInBuf.theBuf[newHead];                              
      tty->rawInBuf.Head = newHead;                                   
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
a00087dc:	e0823003 	add	r3, r2, r3                                    <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
a00087e0:	e0600003 	rsb	r0, r0, r3                                    <== NOT EXECUTED
a00087e4:	eb003046 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
      c = tty->rawInBuf.theBuf[newHead];                              
      tty->rawInBuf.Head = newHead;                                   
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
a00087e8:	e59430bc 	ldr	r3, [r4, #188]	; 0xbc                         <== NOT EXECUTED
a00087ec:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00087f0:	2a000013 	bcs	a0008844 <rtems_termios_read+0x22c>           <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
a00087f4:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
a00087f8:	e3a03c02 	mov	r3, #512	; 0x200                              <== NOT EXECUTED
a00087fc:	e2833002 	add	r3, r3, #2                                    <== NOT EXECUTED
      c = tty->rawInBuf.theBuf[newHead];                              
      tty->rawInBuf.Head = newHead;                                   
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
a0008800:	e3c22001 	bic	r2, r2, #1                                    <== NOT EXECUTED
a0008804:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
a0008808:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a000880c:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
a0008810:	e153000b 	cmp	r3, fp                                        <== NOT EXECUTED
a0008814:	0a000022 	beq	a00088a4 <rtems_termios_read+0x28c>           <== NOT EXECUTED
            && ((tty->rawOutBufState == rob_idle)                     
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
        } else if (tty->flow_ctrl & FL_MDRTS) {                       
a0008818:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a000881c:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a0008820:	0a000007 	beq	a0008844 <rtems_termios_read+0x22c>           <== NOT EXECUTED
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
a0008824:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
a0008828:	e59430b0 	ldr	r3, [r4, #176]	; 0xb0                         <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
        } else if (tty->flow_ctrl & FL_MDRTS) {                       
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
a000882c:	e3c22004 	bic	r2, r2, #4                                    <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
a0008830:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
            tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);     
        } else if (tty->flow_ctrl & FL_MDRTS) {                       
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
a0008834:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
a0008838:	0a000001 	beq	a0008844 <rtems_termios_read+0x22c>           <== NOT EXECUTED
            tty->device.startRemoteTx(tty->minor);                    
a000883c:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0008840:	e12fff33 	blx	r3                                            <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
a0008844:	e594303c 	ldr	r3, [r4, #60]	; 0x3c                          <== NOT EXECUTED
a0008848:	e3130002 	tst	r3, #2                                        <== NOT EXECUTED
a000884c:	1affffc9 	bne	a0008778 <rtems_termios_read+0x160>           <== NOT EXECUTED
        if (siproc (c, tty))                                          
          wait = 0;                                                   
      } else {                                                        
        siproc (c, tty);                                              
a0008850:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0008854:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008858:	ebffff24 	bl	a00084f0 <siproc>                              <== NOT EXECUTED
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
a000885c:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         <== NOT EXECUTED
a0008860:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
          wait = 0;                                                   
      }                                                               
      timeout = tty->rawInBufSemaphoreTimeout;                        
a0008864:	e5946070 	ldr	r6, [r4, #112]	; 0x70                         <== NOT EXECUTED
        if (siproc (c, tty))                                          
          wait = 0;                                                   
      } else {                                                        
        siproc (c, tty);                                              
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
          wait = 0;                                                   
a0008868:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a000886c:	e594205c 	ldr	r2, [r4, #92]	; 0x5c                          <== NOT EXECUTED
a0008870:	e5943060 	ldr	r3, [r4, #96]	; 0x60                          <== NOT EXECUTED
        if (siproc (c, tty))                                          
          wait = 0;                                                   
      } else {                                                        
        siproc (c, tty);                                              
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
          wait = 0;                                                   
a0008874:	a3a05000 	movge	r5, #0                                      <== NOT EXECUTED
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
a0008878:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000887c:	1affffc7 	bne	a00087a0 <rtems_termios_read+0x188>           <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * Wait for characters                                            
     */                                                               
    if ( wait ) {                                                     
a0008880:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a0008884:	0affff86 	beq	a00086a4 <rtems_termios_read+0x8c>            <== NOT EXECUTED
      sc = rtems_semaphore_obtain(                                    
a0008888:	e5940068 	ldr	r0, [r4, #104]	; 0x68                         <== NOT EXECUTED
a000888c:	e594106c 	ldr	r1, [r4, #108]	; 0x6c                         <== NOT EXECUTED
a0008890:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a0008894:	eb000474 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
        tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
      if (sc != RTEMS_SUCCESSFUL)                                     
a0008898:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000889c:	0affffab 	beq	a0008750 <rtems_termios_read+0x138>           <== NOT EXECUTED
a00088a0:	eaffff7f 	b	a00086a4 <rtems_termios_read+0x8c>              <== NOT EXECUTED
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
a00088a4:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
a00088a8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a00088ac:	0a000002 	beq	a00088bc <rtems_termios_read+0x2a4>           <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
a00088b0:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a00088b4:	e3130020 	tst	r3, #32                                       <== NOT EXECUTED
a00088b8:	0affffd6 	beq	a0008818 <rtems_termios_read+0x200>           <== NOT EXECUTED
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
a00088bc:	e59430a4 	ldr	r3, [r4, #164]	; 0xa4                         <== NOT EXECUTED
a00088c0:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a00088c4:	e59d1004 	ldr	r1, [sp, #4]                                  <== NOT EXECUTED
a00088c8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a00088cc:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a00088d0:	eaffffdb 	b	a0008844 <rtems_termios_read+0x22c>             <== NOT EXECUTED
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
a00088d4:	e594203c 	ldr	r2, [r4, #60]	; 0x3c                          <== NOT EXECUTED
a00088d8:	e3120002 	tst	r2, #2                                        <== NOT EXECUTED
a00088dc:	0a00000a 	beq	a000890c <rtems_termios_read+0x2f4>           <== NOT EXECUTED
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
a00088e0:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a00088e4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      if (n < 0) {                                                    
a00088e8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
        rtems_task_wake_after (1);                                    
      } else {                                                        
        if  (siproc (n, tty))                                         
a00088ec:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00088f0:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
      if (n < 0) {                                                    
a00088f4:	ba00002d 	blt	a00089b0 <rtems_termios_read+0x398>           <== NOT EXECUTED
        rtems_task_wake_after (1);                                    
      } else {                                                        
        if  (siproc (n, tty))                                         
a00088f8:	ebfffefc 	bl	a00084f0 <siproc>                              <== NOT EXECUTED
a00088fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008900:	1affff67 	bne	a00086a4 <rtems_termios_read+0x8c>            <== NOT EXECUTED
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
a0008904:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a0008908:	eafffff4 	b	a00088e0 <rtems_termios_read+0x2c8>             <== NOT EXECUTED
      }                                                               
    }                                                                 
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
a000890c:	eb0002b6 	bl	a00093ec <rtems_clock_get_ticks_since_boot>    <== NOT EXECUTED
a0008910:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
a0008914:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a0008918:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a000891c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      if (n < 0) {                                                    
a0008920:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0008924:	ba00000c 	blt	a000895c <rtems_termios_read+0x344>           <== NOT EXECUTED
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
      } else {                                                        
        siproc (n, tty);                                              
a0008928:	e20000ff 	and	r0, r0, #255	; 0xff                           <== NOT EXECUTED
a000892c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008930:	ebfffeee 	bl	a00084f0 <siproc>                              <== NOT EXECUTED
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
a0008934:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         <== NOT EXECUTED
a0008938:	e5942020 	ldr	r2, [r4, #32]                                 <== NOT EXECUTED
a000893c:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0008940:	aaffff57 	bge	a00086a4 <rtems_termios_read+0x8c>            <== NOT EXECUTED
          break;                                                      
        if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])      
a0008944:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008948:	0afffff1 	beq	a0008914 <rtems_termios_read+0x2fc>           <== NOT EXECUTED
a000894c:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         <== NOT EXECUTED
a0008950:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008954:	0affffee 	beq	a0008914 <rtems_termios_read+0x2fc>           <== NOT EXECUTED
a0008958:	eaffffeb 	b	a000890c <rtems_termios_read+0x2f4>             <== NOT EXECUTED
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
      if (n < 0) {                                                    
        if (tty->termios.c_cc[VMIN]) {                                
a000895c:	e5d43047 	ldrb	r3, [r4, #71]	; 0x47                         <== NOT EXECUTED
a0008960:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008964:	0a000008 	beq	a000898c <rtems_termios_read+0x374>           <== NOT EXECUTED
          if (tty->termios.c_cc[VTIME] && tty->ccount) {              
a0008968:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         <== NOT EXECUTED
a000896c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008970:	0a000002 	beq	a0008980 <rtems_termios_read+0x368>           <== NOT EXECUTED
a0008974:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a0008978:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000897c:	1a000005 	bne	a0008998 <rtems_termios_read+0x380>           <== NOT EXECUTED
          now = rtems_clock_get_ticks_since_boot();                   
          if ((now - then) > tty->vtimeTicks) {                       
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
a0008980:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0008984:	eb00056f 	bl	a0009f48 <rtems_task_wake_after>               <== NOT EXECUTED
a0008988:	eaffffe1 	b	a0008914 <rtems_termios_read+0x2fc>             <== NOT EXECUTED
            if ((now - then) > tty->vtimeTicks) {                     
              break;                                                  
            }                                                         
          }                                                           
        } else {                                                      
          if (!tty->termios.c_cc[VTIME])                              
a000898c:	e5d43046 	ldrb	r3, [r4, #70]	; 0x46                         <== NOT EXECUTED
a0008990:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008994:	0affff42 	beq	a00086a4 <rtems_termios_read+0x8c>            <== NOT EXECUTED
            break;                                                    
          now = rtems_clock_get_ticks_since_boot();                   
a0008998:	eb000293 	bl	a00093ec <rtems_clock_get_ticks_since_boot>    <== NOT EXECUTED
          if ((now - then) > tty->vtimeTicks) {                       
a000899c:	e5943054 	ldr	r3, [r4, #84]	; 0x54                          <== NOT EXECUTED
a00089a0:	e0650000 	rsb	r0, r5, r0                                    <== NOT EXECUTED
a00089a4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a00089a8:	9afffff4 	bls	a0008980 <rtems_termios_read+0x368>           <== NOT EXECUTED
a00089ac:	eaffff3c 	b	a00086a4 <rtems_termios_read+0x8c>              <== NOT EXECUTED
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
      if (n < 0) {                                                    
        rtems_task_wake_after (1);                                    
a00089b0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a00089b4:	eb000563 	bl	a0009f48 <rtems_task_wake_after>               <== NOT EXECUTED
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
a00089b8:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a00089bc:	eaffffc7 	b	a00088e0 <rtems_termios_read+0x2c8>             <== NOT EXECUTED
                                                                      

a0008d40 <rtems_termios_refill_transmitter>: int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
a0008d40:	e59030b8 	ldr	r3, [r0, #184]	; 0xb8                         <== NOT EXECUTED
a0008d44:	e3a02b01 	mov	r2, #1024	; 0x400                             <== NOT EXECUTED
a0008d48:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a0008d4c:	e3c33fff 	bic	r3, r3, #1020	; 0x3fc                         <== NOT EXECUTED
a0008d50:	e1a03a83 	lsl	r3, r3, #21                                   <== NOT EXECUTED
 * in task-driven mode, this function is called in Tx task context    
 * in interrupt-driven mode, this function is called in TxIRQ context 
 */                                                                   
int                                                                   
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)      
{                                                                     
a0008d54:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  int nToSend;                                                        
  rtems_interrupt_level level;                                        
  int len;                                                            
                                                                      
  /* check for XOF/XON to send */                                     
  if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))         
a0008d58:	e1a03aa3 	lsr	r3, r3, #21                                   <== NOT EXECUTED
a0008d5c:	e1530002 	cmp	r3, r2                                        <== NOT EXECUTED
 * in task-driven mode, this function is called in Tx task context    
 * in interrupt-driven mode, this function is called in TxIRQ context 
 */                                                                   
int                                                                   
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)      
{                                                                     
a0008d60:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int nToSend;                                                        
  rtems_interrupt_level level;                                        
  int len;                                                            
                                                                      
  /* check for XOF/XON to send */                                     
  if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))         
a0008d64:	0a000047 	beq	a0008e88 <rtems_termios_refill_transmitter+0x148><== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
                                                                      
  } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
a0008d68:	e59030b8 	ldr	r3, [r0, #184]	; 0xb8                         <== NOT EXECUTED
a0008d6c:	e2033003 	and	r3, r3, #3                                    <== NOT EXECUTED
a0008d70:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0008d74:	0a000055 	beq	a0008ed0 <rtems_termios_refill_transmitter+0x190><== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
a0008d78:	e5902080 	ldr	r2, [r0, #128]	; 0x80                         <== NOT EXECUTED
a0008d7c:	e5903084 	ldr	r3, [r0, #132]	; 0x84                         <== NOT EXECUTED
a0008d80:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a0008d84:	0a00002a 	beq	a0008e34 <rtems_termios_refill_transmitter+0xf4><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008d88:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0008d8c:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0008d90:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
      return 0;                                                       
    }                                                                 
                                                                      
    rtems_interrupt_disable(level);                                   
    len = tty->t_dqlen;                                               
    tty->t_dqlen = 0;                                                 
a0008d94:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
      }                                                               
      return 0;                                                       
    }                                                                 
                                                                      
    rtems_interrupt_disable(level);                                   
    len = tty->t_dqlen;                                               
a0008d98:	e5900090 	ldr	r0, [r0, #144]	; 0x90                         <== NOT EXECUTED
    tty->t_dqlen = 0;                                                 
a0008d9c:	e5842090 	str	r2, [r4, #144]	; 0x90                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008da0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
a0008da4:	e5943084 	ldr	r3, [r4, #132]	; 0x84                         <== NOT EXECUTED
a0008da8:	e5941088 	ldr	r1, [r4, #136]	; 0x88                         <== NOT EXECUTED
a0008dac:	e0800003 	add	r0, r0, r3                                    <== NOT EXECUTED
a0008db0:	eb002ed3 	bl	a0014904 <__umodsi3>                           <== NOT EXECUTED
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
a0008db4:	e5943094 	ldr	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
    rtems_interrupt_disable(level);                                   
    len = tty->t_dqlen;                                               
    tty->t_dqlen = 0;                                                 
    rtems_interrupt_enable(level);                                    
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
a0008db8:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    tty->rawOutBuf.Tail = newTail;                                    
a0008dbc:	e5840084 	str	r0, [r4, #132]	; 0x84                         <== NOT EXECUTED
    if (tty->rawOutBufState == rob_wait) {                            
a0008dc0:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
a0008dc4:	0a00002c 	beq	a0008e7c <rtems_termios_refill_transmitter+0x13c><== NOT EXECUTED
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
    }                                                                 
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
a0008dc8:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
a0008dcc:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a0008dd0:	0a00001f 	beq	a0008e54 <rtems_termios_refill_transmitter+0x114><== NOT EXECUTED
      if ( tty->tty_snd.sw_pfn != NULL) {                             
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
      }                                                               
    }                                                                 
    /* check, whether output should stop due to received XOFF */      
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
a0008dd4:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
a0008dd8:	e2033e21 	and	r3, r3, #528	; 0x210                          <== NOT EXECUTED
a0008ddc:	e3530e21 	cmp	r3, #528	; 0x210                              <== NOT EXECUTED
a0008de0:	0a00004c 	beq	a0008f18 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
      nToSend = 0;                                                    
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
a0008de4:	e5943080 	ldr	r3, [r4, #128]	; 0x80                         <== NOT EXECUTED
      /* for outgoing flow control                                   */
      if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {                   
        nToSend = 1;                                                  
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
a0008de8:	e594107c 	ldr	r1, [r4, #124]	; 0x7c                         <== NOT EXECUTED
a0008dec:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
      nToSend = 0;                                                    
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
a0008df0:	e1550003 	cmp	r5, r3                                        <== NOT EXECUTED
        nToSend = tty->rawOutBuf.Size - newTail;                      
a0008df4:	85946088 	ldrhi	r6, [r4, #136]	; 0x88                       <== NOT EXECUTED
      else                                                            
        nToSend = tty->rawOutBuf.Head - newTail;                      
a0008df8:	95946080 	ldrls	r6, [r4, #128]	; 0x80                       <== NOT EXECUTED
      /* when flow control XON or XOF, don't send blocks of data     */
      /* to allow fast reaction on incoming flow ctrl and low latency*/
      /* for outgoing flow control                                   */
      if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {                   
a0008dfc:	e59430b8 	ldr	r3, [r4, #184]	; 0xb8                         <== NOT EXECUTED
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
        nToSend = tty->rawOutBuf.Size - newTail;                      
a0008e00:	80656006 	rsbhi	r6, r5, r6                                  <== NOT EXECUTED
      else                                                            
        nToSend = tty->rawOutBuf.Head - newTail;                      
a0008e04:	90656006 	rsbls	r6, r5, r6                                  <== NOT EXECUTED
      /* when flow control XON or XOF, don't send blocks of data     */
      /* to allow fast reaction on incoming flow ctrl and low latency*/
      /* for outgoing flow control                                   */
      if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {                   
a0008e08:	e3130c06 	tst	r3, #1536	; 0x600                             <== NOT EXECUTED
a0008e0c:	13a06001 	movne	r6, #1                                      <== NOT EXECUTED
        nToSend = 1;                                                  
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
a0008e10:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0008e14:	e5843094 	str	r3, [r4, #148]	; 0x94                         <== NOT EXECUTED
        nToSend = tty->rawOutBuf.Head - newTail;                      
      /* when flow control XON or XOF, don't send blocks of data     */
      /* to allow fast reaction on incoming flow ctrl and low latency*/
      /* for outgoing flow control                                   */
      if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {                   
        nToSend = 1;                                                  
a0008e18:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
a0008e1c:	e59430a4 	ldr	r3, [r4, #164]	; 0xa4                         <== NOT EXECUTED
a0008e20:	e0811005 	add	r1, r1, r5                                    <== NOT EXECUTED
a0008e24:	e12fff33 	blx	r3                                            <== NOT EXECUTED
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
a0008e28:	e5845084 	str	r5, [r4, #132]	; 0x84                         <== NOT EXECUTED
  }                                                                   
  return nToSend;                                                     
}                                                                     
a0008e2c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0008e30:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
      /*                                                              
       * buffer was empty                                             
       */                                                             
      if (tty->rawOutBufState == rob_wait) {                          
a0008e34:	e5903094 	ldr	r3, [r0, #148]	; 0x94                         <== NOT EXECUTED
a0008e38:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
        /*                                                            
         * this should never happen...                                
         */                                                           
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
      }                                                               
      return 0;                                                       
a0008e3c:	13a06000 	movne	r6, #0                                      <== NOT EXECUTED
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
      /*                                                              
       * buffer was empty                                             
       */                                                             
      if (tty->rawOutBufState == rob_wait) {                          
a0008e40:	1afffff9 	bne	a0008e2c <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
        /*                                                            
         * this should never happen...                                
         */                                                           
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
a0008e44:	e590008c 	ldr	r0, [r0, #140]	; 0x8c                         <== NOT EXECUTED
a0008e48:	eb000350 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
      }                                                               
      return 0;                                                       
a0008e4c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0008e50:	eafffff5 	b	a0008e2c <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
      nToSend = 0;                                                    
                                                                      
      /*                                                              
       * check to see if snd wakeup callback was set                  
       */                                                             
      if ( tty->tty_snd.sw_pfn != NULL) {                             
a0008e54:	e59430d4 	ldr	r3, [r4, #212]	; 0xd4                         <== NOT EXECUTED
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
      /*                                                              
       * Buffer has become empty                                      
       */                                                             
      tty->rawOutBufState = rob_idle;                                 
a0008e58:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0008e5c:	e5846094 	str	r6, [r4, #148]	; 0x94                         <== NOT EXECUTED
      nToSend = 0;                                                    
                                                                      
      /*                                                              
       * check to see if snd wakeup callback was set                  
       */                                                             
      if ( tty->tty_snd.sw_pfn != NULL) {                             
a0008e60:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
    if (newTail == tty->rawOutBuf.Head) {                             
      /*                                                              
       * Buffer has become empty                                      
       */                                                             
      tty->rawOutBufState = rob_idle;                                 
      nToSend = 0;                                                    
a0008e64:	01a06003 	moveq	r6, r3                                      <== NOT EXECUTED
                                                                      
      /*                                                              
       * check to see if snd wakeup callback was set                  
       */                                                             
      if ( tty->tty_snd.sw_pfn != NULL) {                             
a0008e68:	0affffee 	beq	a0008e28 <rtems_termios_refill_transmitter+0xe8><== NOT EXECUTED
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
a0008e6c:	e2840030 	add	r0, r4, #48	; 0x30                            <== NOT EXECUTED
a0008e70:	e59410d8 	ldr	r1, [r4, #216]	; 0xd8                         <== NOT EXECUTED
a0008e74:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008e78:	eaffffea 	b	a0008e28 <rtems_termios_refill_transmitter+0xe8><== NOT EXECUTED
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
      /*                                                              
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
a0008e7c:	e594008c 	ldr	r0, [r4, #140]	; 0x8c                         <== NOT EXECUTED
a0008e80:	eb000342 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
a0008e84:	eaffffcf 	b	a0008dc8 <rtems_termios_refill_transmitter+0x88><== NOT EXECUTED
                                                                      
  /* check for XOF/XON to send */                                     
  if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))         
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
a0008e88:	e59030a4 	ldr	r3, [r0, #164]	; 0xa4                         <== NOT EXECUTED
a0008e8c:	e284104a 	add	r1, r4, #74	; 0x4a                            <== NOT EXECUTED
a0008e90:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0008e94:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
a0008e98:	e12fff33 	blx	r3                                            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008e9c:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0008ea0:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0008ea4:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008ea8:	e5941090 	ldr	r1, [r4, #144]	; 0x90                         <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
a0008eac:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008eb0:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
a0008eb4:	e3822002 	orr	r2, r2, #2                                    <== NOT EXECUTED
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008eb8:	e5841090 	str	r1, [r4, #144]	; 0x90                         <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
a0008ebc:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008ec0:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
a0008ec4:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
  }                                                                   
  return nToSend;                                                     
}                                                                     
a0008ec8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0008ecc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
     * FIXME: this .write call will generate another                  
     * dequeue callback. This will advance the "Tail" in the data     
     * buffer, although the corresponding data is not yet out!        
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
a0008ed0:	e59030a4 	ldr	r3, [r0, #164]	; 0xa4                         <== NOT EXECUTED
a0008ed4:	e2841049 	add	r1, r4, #73	; 0x49                            <== NOT EXECUTED
a0008ed8:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
a0008edc:	e5900010 	ldr	r0, [r0, #16]                                 <== NOT EXECUTED
a0008ee0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008ee4:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0008ee8:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0008eec:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008ef0:	e5941090 	ldr	r1, [r4, #144]	; 0x90                         <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
a0008ef4:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008ef8:	e2411001 	sub	r1, r1, #1                                    <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
a0008efc:	e3c22002 	bic	r2, r2, #2                                    <== NOT EXECUTED
     * Therefore the dequeue "length" should be reduced by 1          
     */                                                               
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
                                                                      
    rtems_interrupt_disable(level);                                   
    tty->t_dqlen--;                                                   
a0008f00:	e5841090 	str	r1, [r4, #144]	; 0x90                         <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
a0008f04:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008f08:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
a0008f0c:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
  }                                                                   
  return nToSend;                                                     
}                                                                     
a0008f10:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0008f14:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a0008f18:	e10f3000 	mrs	r3, CPSR                                      <== NOT EXECUTED
a0008f1c:	e3832080 	orr	r2, r3, #128	; 0x80                           <== NOT EXECUTED
a0008f20:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl |= FL_OSTOP;                                     
a0008f24:	e59420b8 	ldr	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
a0008f28:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a0008f2c:	e5841094 	str	r1, [r4, #148]	; 0x94                         <== NOT EXECUTED
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
      tty->flow_ctrl |= FL_OSTOP;                                     
a0008f30:	e3822020 	orr	r2, r2, #32                                   <== NOT EXECUTED
a0008f34:	e58420b8 	str	r2, [r4, #184]	; 0xb8                         <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a0008f38:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
      rtems_interrupt_enable(level);                                  
      nToSend = 0;                                                    
a0008f3c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0008f40:	eaffffb8 	b	a0008e28 <rtems_termios_refill_transmitter+0xe8><== NOT EXECUTED
                                                                      

a0008cb4 <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
a0008cb4:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a0008cb8:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
a0008cbc:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0008cc0:	e28d7007 	add	r7, sp, #7                                    <== NOT EXECUTED
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
a0008cc4:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0008cc8:	ea000005 	b	a0008ce4 <rtems_termios_rxdaemon+0x30>          <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
a0008ccc:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a0008cd0:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0008cd4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    if (c != EOF) {                                                   
a0008cd8:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
a0008cdc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    if (c != EOF) {                                                   
a0008ce0:	1a000010 	bne	a0008d28 <rtems_termios_rxdaemon+0x74>        <== NOT EXECUTED
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
a0008ce4:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
a0008ce8:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a0008cec:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0008cf0:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
a0008cf4:	eb0001dc 	bl	a000946c <rtems_event_receive>                 <== NOT EXECUTED
      (TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),           
      RTEMS_EVENT_ANY | RTEMS_WAIT,                                   
      RTEMS_NO_TIMEOUT,                                               
      &the_event                                                      
    );                                                                
    if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {              
a0008cf8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0008cfc:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a0008d00:	0afffff1 	beq	a0008ccc <rtems_termios_rxdaemon+0x18>        <== NOT EXECUTED
      tty->rxTaskId = 0;                                              
a0008d04:	e58460c4 	str	r6, [r4, #196]	; 0xc4                         <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
a0008d08:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0008d0c:	eb000418 	bl	a0009d74 <rtems_task_delete>                   <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
a0008d10:	e59430a0 	ldr	r3, [r4, #160]	; 0xa0                         <== NOT EXECUTED
a0008d14:	e5940010 	ldr	r0, [r4, #16]                                 <== NOT EXECUTED
a0008d18:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    if (c != EOF) {                                                   
a0008d1c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
a0008d20:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    if (c != EOF) {                                                   
a0008d24:	0affffee 	beq	a0008ce4 <rtems_termios_rxdaemon+0x30>        <== NOT EXECUTED
      /*                                                              
       * pollRead did call enqueue on its own                         
       */                                                             
      c_buf = c;                                                      
      rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);           
a0008d28:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008d2c:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a0008d30:	e3a02001 	mov	r2, #1                                        <== NOT EXECUTED
    c = tty->device.pollRead(tty->minor);                             
    if (c != EOF) {                                                   
      /*                                                              
       * pollRead did call enqueue on its own                         
       */                                                             
      c_buf = c;                                                      
a0008d34:	e5cd3007 	strb	r3, [sp, #7]                                 <== NOT EXECUTED
      rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);           
a0008d38:	ebffff25 	bl	a00089d4 <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
a0008d3c:	eaffffe8 	b	a0008ce4 <rtems_termios_rxdaemon+0x30>          <== NOT EXECUTED
                                                                      

a00089c8 <rtems_termios_rxirq_occured>: void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty) { /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
a00089c8:	e59000c4 	ldr	r0, [r0, #196]	; 0xc4                         <== NOT EXECUTED
a00089cc:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a00089d0:	ea000302 	b	a00095e0 <rtems_event_send>                     <== NOT EXECUTED
                                                                      

a000b22c <rtems_termios_set_initial_baud>: int rtems_termios_set_initial_baud( struct rtems_termios_tty *ttyp, int32_t baud ) {
a000b22c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
a000b230:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  int cflags_baud;                                                    
                                                                      
  cflags_baud = rtems_termios_number_to_baud(baud);                   
a000b234:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000b238:	ebfff8aa 	bl	a00094e8 <rtems_termios_number_to_baud>        <== NOT EXECUTED
  if ( cflags_baud == -1 )                                            
a000b23c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
    return -1;                                                        
                                                                      
  ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
a000b240:	15942038 	ldrne	r2, [r4, #56]	; 0x38                        <== NOT EXECUTED
  int32_t                   baud                                      
)                                                                     
{                                                                     
  int cflags_baud;                                                    
                                                                      
  cflags_baud = rtems_termios_number_to_baud(baud);                   
a000b244:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
  if ( cflags_baud == -1 )                                            
    return -1;                                                        
a000b248:	01a00003 	moveq	r0, r3                                      <== NOT EXECUTED
                                                                      
  ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
a000b24c:	13c22a01 	bicne	r2, r2, #4096	; 0x1000                      <== NOT EXECUTED
a000b250:	13c2200f 	bicne	r2, r2, #15                                 <== NOT EXECUTED
a000b254:	11833002 	orrne	r3, r3, r2                                  <== NOT EXECUTED
                                                                      
  return 0;                                                           
a000b258:	13a00000 	movne	r0, #0                                      <== NOT EXECUTED
                                                                      
  cflags_baud = rtems_termios_number_to_baud(baud);                   
  if ( cflags_baud == -1 )                                            
    return -1;                                                        
                                                                      
  ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
a000b25c:	15843038 	strne	r3, [r4, #56]	; 0x38                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
a000b260:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0008f44 <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
a0008f44:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a0008f48:	e59f6060 	ldr	r6, [pc, #96]	; a0008fb0 <rtems_termios_txdaemon+0x6c><== NOT EXECUTED
a0008f4c:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0008f50:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
a0008f54:	e3a07000 	mov	r7, #0                                        <== NOT EXECUTED
a0008f58:	ea000008 	b	a0008f80 <rtems_termios_txdaemon+0x3c>          <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
a0008f5c:	e59430cc 	ldr	r3, [r4, #204]	; 0xcc                         <== NOT EXECUTED
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
a0008f60:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
a0008f64:	e0863283 	add	r3, r6, r3, lsl #5                            <== NOT EXECUTED
a0008f68:	e5933014 	ldr	r3, [r3, #20]                                 <== NOT EXECUTED
a0008f6c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008f70:	0a000000 	beq	a0008f78 <rtems_termios_txdaemon+0x34>        <== NOT EXECUTED
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
a0008f74:	e12fff33 	blx	r3                                            <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * try to push further characters to device                       
     */                                                               
    rtems_termios_refill_transmitter(tty);                            
a0008f78:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008f7c:	ebffff6f 	bl	a0008d40 <rtems_termios_refill_transmitter>    <== NOT EXECUTED
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
a0008f80:	e1a0300d 	mov	r3, sp                                        <== NOT EXECUTED
a0008f84:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a0008f88:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0008f8c:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
a0008f90:	eb000135 	bl	a000946c <rtems_event_receive>                 <== NOT EXECUTED
       (TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),         
       RTEMS_EVENT_ANY | RTEMS_WAIT,                                  
       RTEMS_NO_TIMEOUT,                                              
       &the_event                                                     
    );                                                                
    if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {              
a0008f94:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0008f98:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a0008f9c:	0affffee 	beq	a0008f5c <rtems_termios_txdaemon+0x18>        <== NOT EXECUTED
      tty->txTaskId = 0;                                              
a0008fa0:	e58470c8 	str	r7, [r4, #200]	; 0xc8                         <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
a0008fa4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0008fa8:	eb000371 	bl	a0009d74 <rtems_task_delete>                   <== NOT EXECUTED
a0008fac:	eaffffea 	b	a0008f5c <rtems_termios_txdaemon+0x18>          <== NOT EXECUTED
                                                                      

a000854c <rtems_termios_write>: rtems_status_code rtems_termios_write (void *arg) { rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
a000854c:	e5903000 	ldr	r3, [r0]                                      <== NOT EXECUTED
  rtems_termios_puts (&c, 1, tty);                                    
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
a0008550:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
a0008554:	e5934034 	ldr	r4, [r3, #52]	; 0x34                          <== NOT EXECUTED
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0008558:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
  rtems_termios_puts (&c, 1, tty);                                    
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
a000855c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
a0008560:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0008564:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a0008568:	eb00053f 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
a000856c:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a0008570:	1a00000b 	bne	a00085a4 <rtems_termios_write+0x58>           <== NOT EXECUTED
    return sc;                                                        
  if (rtems_termios_linesw[tty->t_line].l_write != NULL) {            
a0008574:	e59420cc 	ldr	r2, [r4, #204]	; 0xcc                         <== NOT EXECUTED
a0008578:	e59f3094 	ldr	r3, [pc, #148]	; a0008614 <rtems_termios_write+0xc8><== NOT EXECUTED
a000857c:	e0833282 	add	r3, r3, r2, lsl #5                            <== NOT EXECUTED
a0008580:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a0008584:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008588:	0a000007 	beq	a00085ac <rtems_termios_write+0x60>           <== NOT EXECUTED
    sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);         
a000858c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0008590:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0008594:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0008598:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
    rtems_semaphore_release (tty->osem);                              
a000859c:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a00085a0:	eb00057a 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
  return sc;                                                          
}                                                                     
a00085a4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00085a8:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
  if (rtems_termios_linesw[tty->t_line].l_write != NULL) {            
    sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);         
    rtems_semaphore_release (tty->osem);                              
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
a00085ac:	e5943034 	ldr	r3, [r4, #52]	; 0x34                          <== NOT EXECUTED
a00085b0:	e3130001 	tst	r3, #1                                        <== NOT EXECUTED
a00085b4:	0a000011 	beq	a0008600 <rtems_termios_write+0xb4>           <== NOT EXECUTED
    uint32_t   count = args->count;                                   
a00085b8:	e5958010 	ldr	r8, [r5, #16]                                 <== NOT EXECUTED
    char      *buffer = args->buffer;                                 
a00085bc:	e595a00c 	ldr	sl, [r5, #12]                                 <== NOT EXECUTED
    while (count--)                                                   
a00085c0:	e3580000 	cmp	r8, #0                                        <== NOT EXECUTED
a00085c4:	01a03006 	moveq	r3, r6                                      <== NOT EXECUTED
a00085c8:	0a000007 	beq	a00085ec <rtems_termios_write+0xa0>           <== NOT EXECUTED
a00085cc:	e1a07006 	mov	r7, r6                                        <== NOT EXECUTED
      oproc (*buffer++, tty);                                         
a00085d0:	e7da0007 	ldrb	r0, [sl, r7]                                 <== NOT EXECUTED
a00085d4:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a00085d8:	e2877001 	add	r7, r7, #1                                    <== NOT EXECUTED
a00085dc:	ebfffe47 	bl	a0007f00 <oproc>                               <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
a00085e0:	e1570008 	cmp	r7, r8                                        <== NOT EXECUTED
a00085e4:	1afffff9 	bne	a00085d0 <rtems_termios_write+0x84>           <== NOT EXECUTED
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
a00085e8:	e5953010 	ldr	r3, [r5, #16]                                 <== NOT EXECUTED
a00085ec:	e5853018 	str	r3, [r5, #24]                                 <== NOT EXECUTED
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
a00085f0:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a00085f4:	eb000565 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  return sc;                                                          
}                                                                     
a00085f8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a00085fc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
a0008600:	e595000c 	ldr	r0, [r5, #12]                                 <== NOT EXECUTED
a0008604:	e5951010 	ldr	r1, [r5, #16]                                 <== NOT EXECUTED
a0008608:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000860c:	ebfffdf5 	bl	a0007de8 <rtems_termios_puts>                  <== NOT EXECUTED
a0008610:	eafffff4 	b	a00085e8 <rtems_termios_write+0x9c>             <== NOT EXECUTED
                                                                      

a0019cb0 <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( rtems_id id ) {
a0019cb0:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
a0019cb4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0019cb8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
a0019cbc:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0019cc0:	e59f0034 	ldr	r0, [pc, #52]	; a0019cfc <rtems_timer_cancel+0x4c><== NOT EXECUTED
a0019cc4:	eb000bda 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019cc8:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a0019ccc:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0019cd0:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019cd4:	1a000006 	bne	a0019cf4 <rtems_timer_cancel+0x44>            <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
a0019cd8:	e5903038 	ldr	r3, [r0, #56]	; 0x38                          <== NOT EXECUTED
a0019cdc:	e3530004 	cmp	r3, #4                                        <== NOT EXECUTED
a0019ce0:	0a000001 	beq	a0019cec <rtems_timer_cancel+0x3c>            <== NOT EXECUTED
        (void) _Watchdog_Remove( &the_timer->Ticker );                
a0019ce4:	e2800010 	add	r0, r0, #16                                   <== NOT EXECUTED
a0019ce8:	eb0013b5 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
      _Thread_Enable_dispatch();                                      
a0019cec:	eb000f23 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0019cf0:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0019cf4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0019cf8:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a000a444 <rtems_timer_create>: rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) {
a000a444:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
  Timer_Control *the_timer;                                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000a448:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_timer_create(                                 
  rtems_name  name,                                                   
  rtems_id   *id                                                      
)                                                                     
{                                                                     
a000a44c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  Timer_Control *the_timer;                                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
a000a450:	0a00001a 	beq	a000a4c0 <rtems_timer_create+0x7c>            <== NOT EXECUTED
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
a000a454:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000a458:	0a00001d 	beq	a000a4d4 <rtems_timer_create+0x90>            <== NOT EXECUTED
a000a45c:	e59f3078 	ldr	r3, [pc, #120]	; a000a4dc <rtems_timer_create+0x98><== NOT EXECUTED
a000a460:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a000a464:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a000a468:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
 *  This function allocates a timer control block from                
 *  the inactive chain of free timer control blocks.                  
 */                                                                   
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )           
{                                                                     
  return (Timer_Control *) _Objects_Allocate( &_Timer_Information );  
a000a46c:	e59f606c 	ldr	r6, [pc, #108]	; a000a4e0 <rtems_timer_create+0x9c><== NOT EXECUTED
a000a470:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a474:	eb0003d0 	bl	a000b3bc <_Objects_Allocate>                   <== NOT EXECUTED
                                                                      
  _Thread_Disable_dispatch();         /* to prevent deletion */       
                                                                      
  the_timer = _Timer_Allocate();                                      
                                                                      
  if ( !the_timer ) {                                                 
a000a478:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a47c:	0a000011 	beq	a000a4c8 <rtems_timer_create+0x84>            <== NOT EXECUTED
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
a000a480:	e5903008 	ldr	r3, [r0, #8]                                  <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000a484:	e596201c 	ldr	r2, [r6, #28]                                 <== NOT EXECUTED
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
                                                                      
  the_timer->the_class = TIMER_DORMANT;                               
a000a488:	e3a0c004 	mov	ip, #4                                        <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000a48c:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
a000a490:	e1a01803 	lsl	r1, r3, #16                                   <== NOT EXECUTED
a000a494:	e580c038 	str	ip, [r0, #56]	; 0x38                          <== NOT EXECUTED
a000a498:	e5806018 	str	r6, [r0, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a000a49c:	e580602c 	str	r6, [r0, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a000a4a0:	e5806030 	str	r6, [r0, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a000a4a4:	e5806034 	str	r6, [r0, #52]	; 0x34                          <== NOT EXECUTED
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
a000a4a8:	e7820721 	str	r0, [r2, r1, lsr #14]                         <== NOT EXECUTED
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
a000a4ac:	e580400c 	str	r4, [r0, #12]                                 <== NOT EXECUTED
    &_Timer_Information,                                              
    &the_timer->Object,                                               
    (Objects_Name) name                                               
  );                                                                  
                                                                      
  *id = the_timer->Object.id;                                         
a000a4b0:	e5853000 	str	r3, [r5]                                      <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a000a4b4:	eb000824 	bl	a000c54c <_Thread_Enable_dispatch>             <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;                                            
a000a4b8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a4bc:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
)                                                                     
{                                                                     
  Timer_Control *the_timer;                                           
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
a000a4c0:	e3a00003 	mov	r0, #3                                        <== NOT EXECUTED
a000a4c4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  _Thread_Disable_dispatch();         /* to prevent deletion */       
                                                                      
  the_timer = _Timer_Allocate();                                      
                                                                      
  if ( !the_timer ) {                                                 
    _Thread_Enable_dispatch();                                        
a000a4c8:	eb00081f 	bl	a000c54c <_Thread_Enable_dispatch>             <== NOT EXECUTED
    return RTEMS_TOO_MANY;                                            
a000a4cc:	e3a00005 	mov	r0, #5                                        <== NOT EXECUTED
a000a4d0:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !id )                                                          
    return RTEMS_INVALID_ADDRESS;                                     
a000a4d4:	e3a00009 	mov	r0, #9                                        <== NOT EXECUTED
  );                                                                  
                                                                      
  *id = the_timer->Object.id;                                         
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
a000a4d8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0019da0 <rtems_timer_delete>: */ rtems_status_code rtems_timer_delete( rtems_id id ) {
a0019da0:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0019da4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0019da8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
a0019dac:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0019db0:	e59f0044 	ldr	r0, [pc, #68]	; a0019dfc <rtems_timer_delete+0x5c><== NOT EXECUTED
a0019db4:	eb000b9e 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019db8:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a0019dbc:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0019dc0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0019dc4:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
{                                                                     
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019dc8:	1a000009 	bne	a0019df4 <rtems_timer_delete+0x54>            <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      _Objects_Close( &_Timer_Information, &the_timer->Object );      
a0019dcc:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0019dd0:	e59f0024 	ldr	r0, [pc, #36]	; a0019dfc <rtems_timer_delete+0x5c><== NOT EXECUTED
a0019dd4:	eb000a78 	bl	a001c7bc <_Objects_Close>                      <== NOT EXECUTED
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
a0019dd8:	e2850010 	add	r0, r5, #16                                   <== NOT EXECUTED
a0019ddc:	eb001378 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void _Timer_Free (                               
  Timer_Control *the_timer                                            
)                                                                     
{                                                                     
  _Objects_Free( &_Timer_Information, &the_timer->Object );           
a0019de0:	e59f0014 	ldr	r0, [pc, #20]	; a0019dfc <rtems_timer_delete+0x5c><== NOT EXECUTED
a0019de4:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0019de8:	eb000b28 	bl	a001ca90 <_Objects_Free>                       <== NOT EXECUTED
      _Timer_Free( the_timer );                                       
      _Thread_Enable_dispatch();                                      
a0019dec:	eb000ee3 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0019df0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0019df4:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0019df8:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000a4e4 <rtems_timer_fire_after>: rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) {
a000a4e4:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
  Timer_Control      *the_timer;                                      
  Objects_Locations   location;                                       
  ISR_Level           level;                                          
                                                                      
  if ( ticks == 0 )                                                   
a000a4e8:	e2516000 	subs	r6, r1, #0                                   <== NOT EXECUTED
  rtems_id                           id,                              
  rtems_interval                     ticks,                           
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
a000a4ec:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000a4f0:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a000a4f4:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a000a4f8:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  Timer_Control      *the_timer;                                      
  Objects_Locations   location;                                       
  ISR_Level           level;                                          
                                                                      
  if ( ticks == 0 )                                                   
    return RTEMS_INVALID_NUMBER;                                      
a000a4fc:	03a0000a 	moveq	r0, #10                                     <== NOT EXECUTED
{                                                                     
  Timer_Control      *the_timer;                                      
  Objects_Locations   location;                                       
  ISR_Level           level;                                          
                                                                      
  if ( ticks == 0 )                                                   
a000a500:	0a000020 	beq	a000a588 <rtems_timer_fire_after+0xa4>        <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  if ( !routine )                                                     
a000a504:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a000a508:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  ISR_Level           level;                                          
                                                                      
  if ( ticks == 0 )                                                   
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  if ( !routine )                                                     
a000a50c:	0a00001d 	beq	a000a588 <rtems_timer_fire_after+0xa4>        <== NOT EXECUTED
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
    _Objects_Get( &_Timer_Information, id, location );                
a000a510:	e59f0088 	ldr	r0, [pc, #136]	; a000a5a0 <rtems_timer_fire_after+0xbc><== NOT EXECUTED
a000a514:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000a518:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a000a51c:	eb0004d9 	bl	a000b888 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a000a520:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a000a524:	e1a08000 	mov	r8, r0                                        <== NOT EXECUTED
a000a528:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a000a52c:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !routine )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a000a530:	1a000014 	bne	a000a588 <rtems_timer_fire_after+0xa4>        <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
a000a534:	e288a010 	add	sl, r8, #16                                   <== NOT EXECUTED
a000a538:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a000a53c:	eb000beb 	bl	a000d4f0 <_Watchdog_Remove>                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a000a540:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a000a544:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a000a548:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        /*                                                            
         *  Check to see if the watchdog has just been inserted by a  
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
a000a54c:	e5983018 	ldr	r3, [r8, #24]                                 <== NOT EXECUTED
a000a550:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000a554:	1a00000d 	bne	a000a590 <rtems_timer_fire_after+0xac>        <== NOT EXECUTED
        /*                                                            
         *  OK.  Now we now the timer was not rescheduled by an interrupt
         *  so we can atomically initialize it as in use.             
         */                                                           
                                                                      
        the_timer->the_class = TIMER_INTERVAL;                        
a000a558:	e5883038 	str	r3, [r8, #56]	; 0x38                          <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a000a55c:	e5883018 	str	r3, [r8, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a000a560:	e588402c 	str	r4, [r8, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a000a564:	e5885030 	str	r5, [r8, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a000a568:	e5887034 	str	r7, [r8, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a000a56c:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000a570:	e59f002c 	ldr	r0, [pc, #44]	; a000a5a4 <rtems_timer_fire_after+0xc0><== NOT EXECUTED
a000a574:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a000a578:	e588601c 	str	r6, [r8, #28]                                 <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
a000a57c:	eb000b6c 	bl	a000d334 <_Watchdog_Insert>                    <== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );                                           
                                                                      
                                                                      
      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );            
      _Thread_Enable_dispatch();                                      
a000a580:	eb0007f1 	bl	a000c54c <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a000a584:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a000a588:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a000a58c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
a000a590:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
          _ISR_Enable( level );                                       
          _Thread_Enable_dispatch();                                  
a000a594:	eb0007ec 	bl	a000c54c <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
a000a598:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000a59c:	eafffff9 	b	a000a588 <rtems_timer_fire_after+0xa4>          <== NOT EXECUTED
                                                                      

a0019ec4 <rtems_timer_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
a0019ec4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a0019ec8:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  Timer_Control       *the_timer;                                     
  Objects_Locations    location;                                      
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
a0019ecc:	e59f10d0 	ldr	r1, [pc, #208]	; a0019fa4 <rtems_timer_fire_when+0xe0><== NOT EXECUTED
  rtems_id                            id,                             
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry   routine,                        
  void                               *user_data                       
)                                                                     
{                                                                     
a0019ed0:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a0019ed4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Timer_Control       *the_timer;                                     
  Objects_Locations    location;                                      
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
a0019ed8:	e5d11000 	ldrb	r1, [r1]                                     <== NOT EXECUTED
  rtems_id                            id,                             
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry   routine,                        
  void                               *user_data                       
)                                                                     
{                                                                     
a0019edc:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
a0019ee0:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
  Timer_Control       *the_timer;                                     
  Objects_Locations    location;                                      
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
a0019ee4:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a0019ee8:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
{                                                                     
  Timer_Control       *the_timer;                                     
  Objects_Locations    location;                                      
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
a0019eec:	1a000001 	bne	a0019ef8 <rtems_timer_fire_when+0x34>         <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a0019ef0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0019ef4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
  rtems_interval       seconds;                                       
                                                                      
  if ( !_TOD_Is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
a0019ef8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0019efc:	ebfff4ab 	bl	a00171b0 <_TOD_Validate>                       <== NOT EXECUTED
a0019f00:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0019f04:	0a000009 	beq	a0019f30 <rtems_timer_fire_when+0x6c>         <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  if ( !routine )                                                     
a0019f08:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a0019f0c:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  if ( !routine )                                                     
a0019f10:	0afffff6 	beq	a0019ef0 <rtems_timer_fire_when+0x2c>         <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
a0019f14:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0019f18:	ebfff47d 	bl	a0017114 <_TOD_To_seconds>                     <== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a0019f1c:	e59f8084 	ldr	r8, [pc, #132]	; a0019fa8 <rtems_timer_fire_when+0xe4><== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  if ( !routine )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
a0019f20:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a0019f24:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
a0019f28:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0019f2c:	8a000001 	bhi	a0019f38 <rtems_timer_fire_when+0x74>         <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
a0019f30:	e3a00014 	mov	r0, #20                                       <== NOT EXECUTED
a0019f34:	eaffffed 	b	a0019ef0 <rtems_timer_fire_when+0x2c>           <== NOT EXECUTED
a0019f38:	e59f006c 	ldr	r0, [pc, #108]	; a0019fac <rtems_timer_fire_when+0xe8><== NOT EXECUTED
a0019f3c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0019f40:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0019f44:	eb000b3a 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019f48:	e59da000 	ldr	sl, [sp]                                      <== NOT EXECUTED
a0019f4c:	e1a09000 	mov	r9, r0                                        <== NOT EXECUTED
a0019f50:	e35a0000 	cmp	sl, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0019f54:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
  seconds = _TOD_To_seconds( wall_time );                             
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019f58:	1affffe4 	bne	a0019ef0 <rtems_timer_fire_when+0x2c>         <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
a0019f5c:	e289b010 	add	fp, r9, #16                                   <== NOT EXECUTED
a0019f60:	e1a0000b 	mov	r0, fp                                        <== NOT EXECUTED
a0019f64:	eb001316 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
      the_timer->the_class = TIMER_TIME_OF_DAY;                       
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _Watchdog_Insert_seconds(                                       
a0019f68:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY;                       
a0019f6c:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a0019f70:	e59f0038 	ldr	r0, [pc, #56]	; a0019fb0 <rtems_timer_fire_when+0xec><== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _Watchdog_Insert_seconds(                                       
a0019f74:	e0636006 	rsb	r6, r3, r6                                    <== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY;                       
a0019f78:	e5892038 	str	r2, [r9, #56]	; 0x38                          <== NOT EXECUTED
a0019f7c:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a0019f80:	e589a018 	str	sl, [r9, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a0019f84:	e589402c 	str	r4, [r9, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a0019f88:	e5895030 	str	r5, [r9, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a0019f8c:	e5897034 	str	r7, [r9, #52]	; 0x34                          <== NOT EXECUTED
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
a0019f90:	e589601c 	str	r6, [r9, #28]                                 <== NOT EXECUTED
                                                                      
  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );         
a0019f94:	eb00129b 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _Watchdog_Insert_seconds(                                       
         &the_timer->Ticker,                                          
         seconds - _TOD_Seconds_since_epoch()                         
       );                                                             
      _Thread_Enable_dispatch();                                      
a0019f98:	eb000e78 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a0019f9c:	e1a0000a 	mov	r0, sl                                        <== NOT EXECUTED
a0019fa0:	eaffffd2 	b	a0019ef0 <rtems_timer_fire_when+0x2c>           <== NOT EXECUTED
                                                                      

a0019fb4 <rtems_timer_get_information>: rtems_status_code rtems_timer_get_information( rtems_id id, rtems_timer_information *the_info ) {
a0019fb4:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  if ( !the_info )                                                    
a0019fb8:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
                                                                      
rtems_status_code rtems_timer_get_information(                        
  rtems_id                 id,                                        
  rtems_timer_information *the_info                                   
)                                                                     
{                                                                     
a0019fbc:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a0019fc0:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  if ( !the_info )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
a0019fc4:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
)                                                                     
{                                                                     
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
                                                                      
  if ( !the_info )                                                    
a0019fc8:	0a00000e 	beq	a001a008 <rtems_timer_get_information+0x54>   <== NOT EXECUTED
a0019fcc:	e59f003c 	ldr	r0, [pc, #60]	; a001a010 <rtems_timer_get_information+0x5c><== NOT EXECUTED
a0019fd0:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a0019fd4:	eb000b16 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019fd8:	e59d5000 	ldr	r5, [sp]                                      <== NOT EXECUTED
a0019fdc:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a0019fe0:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( !the_info )                                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a0019fe4:	1a000007 	bne	a001a008 <rtems_timer_get_information+0x54>   <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      the_info->the_class  = the_timer->the_class;                    
a0019fe8:	e590c038 	ldr	ip, [r0, #56]	; 0x38                          <== NOT EXECUTED
      the_info->initial    = the_timer->Ticker.initial;               
a0019fec:	e590101c 	ldr	r1, [r0, #28]                                 <== NOT EXECUTED
      the_info->start_time = the_timer->Ticker.start_time;            
a0019ff0:	e5902024 	ldr	r2, [r0, #36]	; 0x24                          <== NOT EXECUTED
      the_info->stop_time  = the_timer->Ticker.stop_time;             
a0019ff4:	e5903028 	ldr	r3, [r0, #40]	; 0x28                          <== NOT EXECUTED
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      the_info->the_class  = the_timer->the_class;                    
a0019ff8:	e584c000 	str	ip, [r4]                                      <== NOT EXECUTED
      the_info->initial    = the_timer->Ticker.initial;               
a0019ffc:	e984000e 	stmib	r4, {r1, r2, r3}                            <== NOT EXECUTED
      the_info->start_time = the_timer->Ticker.start_time;            
      the_info->stop_time  = the_timer->Ticker.stop_time;             
      _Thread_Enable_dispatch();                                      
a001a000:	eb000e5e 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a001a004:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a001a008:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001a00c:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a001a014 <rtems_timer_ident>: rtems_status_code rtems_timer_ident( rtems_name name, rtems_id *id ) {
a001a014:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a001a018:	e1a03001 	mov	r3, r1                                        <== NOT EXECUTED
a001a01c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;                           
                                                                      
  status = _Objects_Name_to_id_u32(                                   
a001a020:	e1a01002 	mov	r1, r2                                        <== NOT EXECUTED
a001a024:	e59f0010 	ldr	r0, [pc, #16]	; a001a03c <rtems_timer_ident+0x28><== NOT EXECUTED
a001a028:	e3e02102 	mvn	r2, #-2147483648	; 0x80000000                 <== NOT EXECUTED
a001a02c:	eb000b55 	bl	a001cd88 <_Objects_Name_to_id_u32>             <== NOT EXECUTED
    name,                                                             
    OBJECTS_SEARCH_LOCAL_NODE,                                        
    id                                                                
  );                                                                  
                                                                      
  return _Status_Object_name_errors_to_status[ status ];              
a001a030:	e59f3008 	ldr	r3, [pc, #8]	; a001a040 <rtems_timer_ident+0x2c><== NOT EXECUTED
}                                                                     
a001a034:	e7930100 	ldr	r0, [r3, r0, lsl #2]                          <== NOT EXECUTED
a001a038:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a001a6c0 <rtems_timer_initiate_server>: rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) {
a001a6c0:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a001a6c4:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a001a6c8:	e24dd00c 	sub	sp, sp, #12                                   <== NOT EXECUTED
a001a6cc:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
a001a6d0:	e1a08002 	mov	r8, r2                                        <== NOT EXECUTED
a001a6d4:	0a00004a 	beq	a001a804 <rtems_timer_initiate_server+0x144>  <== NOT EXECUTED
            ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );             
a001a6d8:	e59f313c 	ldr	r3, [pc, #316]	; a001a81c <rtems_timer_initiate_server+0x15c><== NOT EXECUTED
a001a6dc:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
a001a6e0:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a001a6e4:	9a00004a 	bls	a001a814 <rtems_timer_initiate_server+0x154>  <== NOT EXECUTED
   *  structured so we check it is invalid before looking for         
   *  a specific invalid value as the default.                        
   */                                                                 
  _priority = priority;                                               
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {                
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )            
a001a6e8:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
      return RTEMS_INVALID_PRIORITY;                                  
    _priority = 0;                                                    
a001a6ec:	03a07000 	moveq	r7, #0                                      <== NOT EXECUTED
   *  structured so we check it is invalid before looking for         
   *  a specific invalid value as the default.                        
   */                                                                 
  _priority = priority;                                               
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {                
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )            
a001a6f0:	1a000043 	bne	a001a804 <rtems_timer_initiate_server+0x144>  <== NOT EXECUTED
a001a6f4:	e59f3124 	ldr	r3, [pc, #292]	; a001a820 <rtems_timer_initiate_server+0x160><== NOT EXECUTED
a001a6f8:	e5932000 	ldr	r2, [r3]                                      <== NOT EXECUTED
a001a6fc:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
a001a700:	e5832000 	str	r2, [r3]                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Just to make sure this is only called once.                     
   */                                                                 
  _Thread_Disable_dispatch();                                         
    tmpInitialized  = initialized;                                    
a001a704:	e59f4118 	ldr	r4, [pc, #280]	; a001a824 <rtems_timer_initiate_server+0x164><== NOT EXECUTED
    initialized = true;                                               
a001a708:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Just to make sure this is only called once.                     
   */                                                                 
  _Thread_Disable_dispatch();                                         
    tmpInitialized  = initialized;                                    
a001a70c:	e5d45000 	ldrb	r5, [r4]                                     <== NOT EXECUTED
    initialized = true;                                               
a001a710:	e5c43000 	strb	r3, [r4]                                     <== NOT EXECUTED
  _Thread_Enable_dispatch();                                          
a001a714:	eb000c99 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
                                                                      
  if ( tmpInitialized )                                               
a001a718:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
a001a71c:	13a0300e 	movne	r3, #14                                     <== NOT EXECUTED
  _Thread_Disable_dispatch();                                         
    tmpInitialized  = initialized;                                    
    initialized = true;                                               
  _Thread_Enable_dispatch();                                          
                                                                      
  if ( tmpInitialized )                                               
a001a720:	1a000038 	bne	a001a808 <rtems_timer_initiate_server+0x148>  <== NOT EXECUTED
   *  other library rules.  For example, if using a TSR written in Ada the
   *  Server should run at the same priority as the priority Ada task.
   *  Otherwise, the priority ceiling for the mutex used to protect the
   *  GNAT run-time is violated.                                      
   */                                                                 
  status = rtems_task_create(                                         
a001a724:	e388c902 	orr	ip, r8, #32768	; 0x8000                       <== NOT EXECUTED
a001a728:	e3a03c01 	mov	r3, #256	; 0x100                              <== NOT EXECUTED
a001a72c:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a001a730:	e59f00f0 	ldr	r0, [pc, #240]	; a001a828 <rtems_timer_initiate_server+0x168><== NOT EXECUTED
a001a734:	e28dc008 	add	ip, sp, #8                                    <== NOT EXECUTED
a001a738:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a001a73c:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a001a740:	e58dc004 	str	ip, [sp, #4]                                  <== NOT EXECUTED
a001a744:	ebfffb05 	bl	a0019360 <rtems_task_create>                   <== NOT EXECUTED
                          /* user may want floating point but we need */
                          /*   system task specified for 0 priority */
    attribute_set | RTEMS_SYSTEM_TASK,                                
    &id                   /* get the id back */                       
  );                                                                  
  if (status) {                                                       
a001a748:	e2503000 	subs	r3, r0, #0                                   <== NOT EXECUTED
    initialized = false;                                              
a001a74c:	15c45000 	strbne	r5, [r4]                                   <== NOT EXECUTED
                          /* user may want floating point but we need */
                          /*   system task specified for 0 priority */
    attribute_set | RTEMS_SYSTEM_TASK,                                
    &id                   /* get the id back */                       
  );                                                                  
  if (status) {                                                       
a001a750:	1a00002c 	bne	a001a808 <rtems_timer_initiate_server+0x148>  <== NOT EXECUTED
   */                                                                 
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return NULL;                                                    
  #endif                                                              
  return information->local_table[ index ];                           
a001a754:	e59f20d0 	ldr	r2, [pc, #208]	; a001a82c <rtems_timer_initiate_server+0x16c><== NOT EXECUTED
   *  We work with the TCB pointer, not the ID, so we need to convert 
   *  to a TCB pointer from here out.                                 
   */                                                                 
  ts->thread = (Thread_Control *)_Objects_Get_local_object(           
    &_RTEMS_tasks_Information,                                        
    _Objects_Get_index(id)                                            
a001a758:	e59de008 	ldr	lr, [sp, #8]                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  We work with the TCB pointer, not the ID, so we need to convert 
   *  to a TCB pointer from here out.                                 
   */                                                                 
  ts->thread = (Thread_Control *)_Objects_Get_local_object(           
a001a75c:	e1a0c004 	mov	ip, r4                                        <== NOT EXECUTED
a001a760:	e592201c 	ldr	r2, [r2, #28]                                 <== NOT EXECUTED
a001a764:	e1a0180e 	lsl	r1, lr, #16                                   <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a001a768:	e59f50c0 	ldr	r5, [pc, #192]	; a001a830 <rtems_timer_initiate_server+0x170><== NOT EXECUTED
a001a76c:	e7922721 	ldr	r2, [r2, r1, lsr #14]                         <== NOT EXECUTED
   *  Initialize the pointer to the timer schedule method so applications that
   *  do not use the Timer Server do not have to pull it in.          
   */                                                                 
  ts->schedule_operation = _Timer_server_Schedule_operation_method;   
                                                                      
  ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;  
a001a770:	e59f10bc 	ldr	r1, [pc, #188]	; a001a834 <rtems_timer_initiate_server+0x174><== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
a001a774:	e5843038 	str	r3, [r4, #56]	; 0x38                          <== NOT EXECUTED
a001a778:	e5843070 	str	r3, [r4, #112]	; 0x70                         <== NOT EXECUTED
a001a77c:	e5918000 	ldr	r8, [r1]                                      <== NOT EXECUTED
  ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a001a780:	e59f10b0 	ldr	r1, [pc, #176]	; a001a838 <rtems_timer_initiate_server+0x178><== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a001a784:	e5843014 	str	r3, [r4, #20]                                 <== NOT EXECUTED
   *  Initialize the pointer to the timer schedule method so applications that
   *  do not use the Timer Server do not have to pull it in.          
   */                                                                 
  ts->schedule_operation = _Timer_server_Schedule_operation_method;   
                                                                      
  ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;  
a001a788:	e5848040 	str	r8, [r4, #64]	; 0x40                          <== NOT EXECUTED
  ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a001a78c:	e591a000 	ldr	sl, [r1]                                      <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
a001a790:	e5843030 	str	r3, [r4, #48]	; 0x30                          <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a001a794:	e584304c 	str	r3, [r4, #76]	; 0x4c                          <== NOT EXECUTED
a001a798:	e584a078 	str	sl, [r4, #120]	; 0x78                         <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
a001a79c:	e5843068 	str	r3, [r4, #104]	; 0x68                         <== NOT EXECUTED
                                                                      
  ts->insert_chain = NULL;                                            
a001a7a0:	e584307c 	str	r3, [r4, #124]	; 0x7c                         <== NOT EXECUTED
  ts->active = false;                                                 
a001a7a4:	e5c43080 	strb	r3, [r4, #128]	; 0x80                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the pointer to the timer schedule method so applications that
   *  do not use the Timer Server do not have to pull it in.          
   */                                                                 
  ts->schedule_operation = _Timer_server_Schedule_operation_method;   
a001a7a8:	e59f308c 	ldr	r3, [pc, #140]	; a001a83c <rtems_timer_initiate_server+0x17c><== NOT EXECUTED
                                                                      
  /*                                                                  
   *  We work with the TCB pointer, not the ID, so we need to convert 
   *  to a TCB pointer from here out.                                 
   */                                                                 
  ts->thread = (Thread_Control *)_Objects_Get_local_object(           
a001a7ac:	e5ac2004 	str	r2, [ip, #4]!                                 <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a7b0:	e2847038 	add	r7, r4, #56	; 0x38                            <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Initialize the pointer to the timer schedule method so applications that
   *  do not use the Timer Server do not have to pull it in.          
   */                                                                 
  ts->schedule_operation = _Timer_server_Schedule_operation_method;   
a001a7b4:	e5843008 	str	r3, [r4, #8]                                  <== NOT EXECUTED
  ts->active = false;                                                 
                                                                      
  /*                                                                  
   * The default timer server is now available.                       
   */                                                                 
  _Timer_server = ts;                                                 
a001a7b8:	e59f3080 	ldr	r3, [pc, #128]	; a001a840 <rtems_timer_initiate_server+0x180><== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
a001a7bc:	e2849034 	add	r9, r4, #52	; 0x34                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a7c0:	e284b070 	add	fp, r4, #112	; 0x70                           <== NOT EXECUTED
a001a7c4:	e583c000 	str	ip, [r3]                                      <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
a001a7c8:	e284606c 	add	r6, r4, #108	; 0x6c                           <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Start the timer server                                          
   */                                                                 
  status = rtems_task_start(                                          
a001a7cc:	e1a0000e 	mov	r0, lr                                        <== NOT EXECUTED
a001a7d0:	e59f106c 	ldr	r1, [pc, #108]	; a001a844 <rtems_timer_initiate_server+0x184><== NOT EXECUTED
a001a7d4:	e1a0200c 	mov	r2, ip                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a7d8:	e5847034 	str	r7, [r4, #52]	; 0x34                          <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
a001a7dc:	e584903c 	str	r9, [r4, #60]	; 0x3c                          <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
a001a7e0:	e584b06c 	str	fp, [r4, #108]	; 0x6c                         <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
a001a7e4:	e5846074 	str	r6, [r4, #116]	; 0x74                         <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a001a7e8:	e5845028 	str	r5, [r4, #40]	; 0x28                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a001a7ec:	e584e02c 	str	lr, [r4, #44]	; 0x2c                          <== NOT EXECUTED
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
a001a7f0:	e5845060 	str	r5, [r4, #96]	; 0x60                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a001a7f4:	e584e064 	str	lr, [r4, #100]	; 0x64                         <== NOT EXECUTED
a001a7f8:	ebfffc9d 	bl	a0019a74 <rtems_task_start>                    <== NOT EXECUTED
a001a7fc:	e1a03000 	mov	r3, r0                                        <== NOT EXECUTED
    if (status) {                                                     
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
a001a800:	ea000000 	b	a001a808 <rtems_timer_initiate_server+0x148>    <== NOT EXECUTED
   *  a specific invalid value as the default.                        
   */                                                                 
  _priority = priority;                                               
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {                
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )            
      return RTEMS_INVALID_PRIORITY;                                  
a001a804:	e3a03013 	mov	r3, #19                                       <== NOT EXECUTED
      initialized = false;                                            
    }                                                                 
  #endif                                                              
                                                                      
  return status;                                                      
}                                                                     
a001a808:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a001a80c:	e28dd00c 	add	sp, sp, #12                                   <== NOT EXECUTED
a001a810:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
a001a814:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a001a818:	eaffffb5 	b	a001a6f4 <rtems_timer_initiate_server+0x34>     <== NOT EXECUTED
                                                                      

a001a044 <rtems_timer_reset>: */ rtems_status_code rtems_timer_reset( rtems_id id ) {
a001a044:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a001a048:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
a001a04c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a001a050:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a001a054:	e59f0088 	ldr	r0, [pc, #136]	; a001a0e4 <rtems_timer_reset+0xa0><== NOT EXECUTED
a001a058:	eb000af5 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
  rtems_status_code  status = RTEMS_SUCCESSFUL;                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a05c:	e59d4000 	ldr	r4, [sp]                                      <== NOT EXECUTED
a001a060:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a001a064:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a001a068:	13a05004 	movne	r5, #4                                      <== NOT EXECUTED
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
  rtems_status_code  status = RTEMS_SUCCESSFUL;                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a06c:	1a000006 	bne	a001a08c <rtems_timer_reset+0x48>             <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( the_timer->the_class == TIMER_INTERVAL ) {                 
a001a070:	e5905038 	ldr	r5, [r0, #56]	; 0x38                          <== NOT EXECUTED
a001a074:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a001a078:	0a000006 	beq	a001a098 <rtems_timer_reset+0x54>             <== NOT EXECUTED
        _Watchdog_Remove( &the_timer->Ticker );                       
        _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
      } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {  
a001a07c:	e3550001 	cmp	r5, #1                                        <== NOT EXECUTED
        /*                                                            
         *  Must be dormant or time of day timer (e.g. TIMER_DORMANT, 
         *  TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK).  We     
         *  can only reset active interval timers.                    
         */                                                           
        status = RTEMS_NOT_DEFINED;                                   
a001a080:	13a0500b 	movne	r5, #11                                     <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( the_timer->the_class == TIMER_INTERVAL ) {                 
        _Watchdog_Remove( &the_timer->Ticker );                       
        _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
      } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {  
a001a084:	0a00000b 	beq	a001a0b8 <rtems_timer_reset+0x74>             <== NOT EXECUTED
         *  TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK).  We     
         *  can only reset active interval timers.                    
         */                                                           
        status = RTEMS_NOT_DEFINED;                                   
      }                                                               
      _Thread_Enable_dispatch();                                      
a001a088:	eb000e3c 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a001a08c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001a090:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001a094:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( the_timer->the_class == TIMER_INTERVAL ) {                 
        _Watchdog_Remove( &the_timer->Ticker );                       
a001a098:	e2806010 	add	r6, r0, #16                                   <== NOT EXECUTED
a001a09c:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a001a0a0:	eb0012c7 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
        _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
a001a0a4:	e59f003c 	ldr	r0, [pc, #60]	; a001a0e8 <rtems_timer_reset+0xa4><== NOT EXECUTED
a001a0a8:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a001a0ac:	eb001255 	bl	a001ea08 <_Watchdog_Insert>                    <== NOT EXECUTED
         *  TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK).  We     
         *  can only reset active interval timers.                    
         */                                                           
        status = RTEMS_NOT_DEFINED;                                   
      }                                                               
      _Thread_Enable_dispatch();                                      
a001a0b0:	eb000e32 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
a001a0b4:	eafffff4 	b	a001a08c <rtems_timer_reset+0x48>               <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      if ( the_timer->the_class == TIMER_INTERVAL ) {                 
        _Watchdog_Remove( &the_timer->Ticker );                       
        _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
      } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {  
        Timer_server_Control *timer_server = _Timer_server;           
a001a0b8:	e59f302c 	ldr	r3, [pc, #44]	; a001a0ec <rtems_timer_reset+0xa8><== NOT EXECUTED
          if ( !timer_server ) {                                      
            _Thread_Enable_dispatch();                                
            return RTEMS_INCORRECT_STATE;                             
          }                                                           
        #endif                                                        
        _Watchdog_Remove( &the_timer->Ticker );                       
a001a0bc:	e2800010 	add	r0, r0, #16                                   <== NOT EXECUTED
    case OBJECTS_LOCAL:                                               
      if ( the_timer->the_class == TIMER_INTERVAL ) {                 
        _Watchdog_Remove( &the_timer->Ticker );                       
        _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
      } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {  
        Timer_server_Control *timer_server = _Timer_server;           
a001a0c0:	e5935000 	ldr	r5, [r3]                                      <== NOT EXECUTED
          if ( !timer_server ) {                                      
            _Thread_Enable_dispatch();                                
            return RTEMS_INCORRECT_STATE;                             
          }                                                           
        #endif                                                        
        _Watchdog_Remove( &the_timer->Ticker );                       
a001a0c4:	eb0012be 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
        (*timer_server->schedule_operation)( timer_server, the_timer );
a001a0c8:	e5953004 	ldr	r3, [r5, #4]                                  <== NOT EXECUTED
a001a0cc:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a001a0d0:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a001a0d4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  rtems_id id                                                         
)                                                                     
{                                                                     
  Timer_Control     *the_timer;                                       
  Objects_Locations  location;                                        
  rtems_status_code  status = RTEMS_SUCCESSFUL;                       
a001a0d8:	e1a05004 	mov	r5, r4                                        <== NOT EXECUTED
         *  TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK).  We     
         *  can only reset active interval timers.                    
         */                                                           
        status = RTEMS_NOT_DEFINED;                                   
      }                                                               
      _Thread_Enable_dispatch();                                      
a001a0dc:	eb000e27 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
a001a0e0:	eaffffe9 	b	a001a08c <rtems_timer_reset+0x48>               <== NOT EXECUTED
                                                                      

a001a0f0 <rtems_timer_server_fire_after>: rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) {
a001a0f0:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}                 <== NOT EXECUTED
a001a0f4:	e1a06001 	mov	r6, r1                                        <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  ISR_Level             level;                                        
  Timer_server_Control *timer_server = _Timer_server;                 
a001a0f8:	e59f10cc 	ldr	r1, [pc, #204]	; a001a1cc <rtems_timer_server_fire_after+0xdc><== NOT EXECUTED
  rtems_id                           id,                              
  rtems_interval                     ticks,                           
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
a001a0fc:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a001a100:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  ISR_Level             level;                                        
  Timer_server_Control *timer_server = _Timer_server;                 
a001a104:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
  rtems_id                           id,                              
  rtems_interval                     ticks,                           
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
a001a108:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a001a10c:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  ISR_Level             level;                                        
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
a001a110:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
a001a114:	03a0000e 	moveq	r0, #14                                     <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  ISR_Level             level;                                        
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
a001a118:	0a000005 	beq	a001a134 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !routine )                                                     
a001a11c:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a001a120:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !routine )                                                     
a001a124:	0a000002 	beq	a001a134 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( ticks == 0 )                                                   
a001a128:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;                                      
a001a12c:	03a0000a 	moveq	r0, #10                                     <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !routine )                                                     
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( ticks == 0 )                                                   
a001a130:	1a000001 	bne	a001a13c <rtems_timer_server_fire_after+0x4c> <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a001a134:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001a138:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                  <== NOT EXECUTED
a001a13c:	e59f008c 	ldr	r0, [pc, #140]	; a001a1d0 <rtems_timer_server_fire_after+0xe0><== NOT EXECUTED
a001a140:	e1a01007 	mov	r1, r7                                        <== NOT EXECUTED
a001a144:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a001a148:	eb000ab9 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
                                                                      
  if ( ticks == 0 )                                                   
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a14c:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
a001a150:	e1a0a000 	mov	sl, r0                                        <== NOT EXECUTED
a001a154:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a001a158:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
                                                                      
  if ( ticks == 0 )                                                   
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a15c:	1afffff4 	bne	a001a134 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
a001a160:	e28a0010 	add	r0, sl, #16                                   <== NOT EXECUTED
a001a164:	eb001296 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )                  
{                                                                     
  uint32_t arm_switch_reg;                                            
  uint32_t level;                                                     
                                                                      
  __asm__ volatile (                                                  
a001a168:	e10f2000 	mrs	r2, CPSR                                      <== NOT EXECUTED
a001a16c:	e3823080 	orr	r3, r2, #128	; 0x80                           <== NOT EXECUTED
a001a170:	e129f003 	msr	CPSR_fc, r3                                   <== NOT EXECUTED
        /*                                                            
         *  Check to see if the watchdog has just been inserted by a  
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
a001a174:	e59a3018 	ldr	r3, [sl, #24]                                 <== NOT EXECUTED
a001a178:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a001a17c:	1a00000e 	bne	a001a1bc <rtems_timer_server_fire_after+0xcc> <== NOT EXECUTED
        /*                                                            
         *  OK.  Now we now the timer was not rescheduled by an interrupt
         *  so we can atomically initialize it as in use.             
         */                                                           
                                                                      
        the_timer->the_class = TIMER_INTERVAL_ON_TASK;                
a001a180:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a001a184:	e58a1038 	str	r1, [sl, #56]	; 0x38                          <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a001a188:	e58a3018 	str	r3, [sl, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a001a18c:	e58a502c 	str	r5, [sl, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a001a190:	e58a7030 	str	r7, [sl, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a001a194:	e58a8034 	str	r8, [sl, #52]	; 0x34                          <== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
        the_timer->Ticker.initial = ticks;                            
a001a198:	e58a601c 	str	r6, [sl, #28]                                 <== NOT EXECUTED
                                                                      
static inline void arm_interrupt_enable( uint32_t level )             
{                                                                     
  ARM_SWITCH_REGISTERS;                                               
                                                                      
  __asm__ volatile (                                                  
a001a19c:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
      _ISR_Enable( level );                                           
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
a001a1a0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001a1a4:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a001a1a8:	e1a0100a 	mov	r1, sl                                        <== NOT EXECUTED
a001a1ac:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
      _Thread_Enable_dispatch();                                      
a001a1b0:	eb000df2 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a001a1b4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a001a1b8:	eaffffdd 	b	a001a134 <rtems_timer_server_fire_after+0x44>   <== NOT EXECUTED
a001a1bc:	e129f002 	msr	CPSR_fc, r2                                   <== NOT EXECUTED
         *  higher priority interrupt.  If so, abandon this insert.   
         */                                                           
                                                                      
        if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {         
          _ISR_Enable( level );                                       
          _Thread_Enable_dispatch();                                  
a001a1c0:	eb000dee 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
          return RTEMS_SUCCESSFUL;                                    
a001a1c4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a001a1c8:	eaffffd9 	b	a001a134 <rtems_timer_server_fire_after+0x44>   <== NOT EXECUTED
                                                                      

a001a1d4 <rtems_timer_server_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
a001a1d4:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
a001a1d8:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
a001a1dc:	e59f10e0 	ldr	r1, [pc, #224]	; a001a2c4 <rtems_timer_server_fire_when+0xf0><== NOT EXECUTED
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
a001a1e0:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
a001a1e4:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
a001a1e8:	e5914000 	ldr	r4, [r1]                                      <== NOT EXECUTED
  rtems_id                           id,                              
  rtems_time_of_day                  *wall_time,                      
  rtems_timer_service_routine_entry  routine,                         
  void                              *user_data                        
)                                                                     
{                                                                     
a001a1ec:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
a001a1f0:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
a001a1f4:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
a001a1f8:	03a0000e 	moveq	r0, #14                                     <== NOT EXECUTED
  Timer_Control        *the_timer;                                    
  Objects_Locations     location;                                     
  rtems_interval        seconds;                                      
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
a001a1fc:	0a00000c 	beq	a001a234 <rtems_timer_server_fire_when+0x60>  <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a001a200:	e59f30c0 	ldr	r3, [pc, #192]	; a001a2c8 <rtems_timer_server_fire_when+0xf4><== NOT EXECUTED
a001a204:	e5d33000 	ldrb	r3, [r3]                                     <== NOT EXECUTED
a001a208:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
a001a20c:	03a0000b 	moveq	r0, #11                                     <== NOT EXECUTED
  Timer_server_Control *timer_server = _Timer_server;                 
                                                                      
  if ( !timer_server )                                                
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
a001a210:	0a000007 	beq	a001a234 <rtems_timer_server_fire_when+0x60>  <== NOT EXECUTED
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
a001a214:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
a001a218:	03a00009 	moveq	r0, #9                                      <== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD_Is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
a001a21c:	0a000004 	beq	a001a234 <rtems_timer_server_fire_when+0x60>  <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
a001a220:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a001a224:	ebfff3e1 	bl	a00171b0 <_TOD_Validate>                       <== NOT EXECUTED
a001a228:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a001a22c:	1a000002 	bne	a001a23c <rtems_timer_server_fire_when+0x68>  <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
    return RTEMS_INVALID_CLOCK;                                       
a001a230:	e3a00014 	mov	r0, #20                                       <== NOT EXECUTED
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
a001a234:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a001a238:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
a001a23c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a001a240:	ebfff3b3 	bl	a0017114 <_TOD_To_seconds>                     <== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a001a244:	e59fa080 	ldr	sl, [pc, #128]	; a001a2cc <rtems_timer_server_fire_when+0xf8><== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
a001a248:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
a001a24c:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
a001a250:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a001a254:	9afffff5 	bls	a001a230 <rtems_timer_server_fire_when+0x5c>  <== NOT EXECUTED
a001a258:	e59f0070 	ldr	r0, [pc, #112]	; a001a2d0 <rtems_timer_server_fire_when+0xfc><== NOT EXECUTED
a001a25c:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a001a260:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
a001a264:	eb000a72 	bl	a001cc34 <_Objects_Get>                        <== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a268:	e59d9000 	ldr	r9, [sp]                                      <== NOT EXECUTED
a001a26c:	e1a0b000 	mov	fp, r0                                        <== NOT EXECUTED
a001a270:	e3590000 	cmp	r9, #0                                        <== NOT EXECUTED
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
a001a274:	13a00004 	movne	r0, #4                                      <== NOT EXECUTED
  seconds = _TOD_To_seconds( wall_time );                             
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
a001a278:	1affffed 	bne	a001a234 <rtems_timer_server_fire_when+0x60>  <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
a001a27c:	e28b0010 	add	r0, fp, #16                                   <== NOT EXECUTED
a001a280:	eb00124f 	bl	a001ebc4 <_Watchdog_Remove>                    <== NOT EXECUTED
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
a001a284:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
a001a288:	e3a02003 	mov	r2, #3                                        <== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
a001a28c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
a001a290:	e0637007 	rsb	r7, r3, r7                                    <== NOT EXECUTED
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
a001a294:	e58b2038 	str	r2, [fp, #56]	; 0x38                          <== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
a001a298:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a001a29c:	e1a0100b 	mov	r1, fp                                        <== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
a001a2a0:	e58b9018 	str	r9, [fp, #24]                                 <== NOT EXECUTED
  the_watchdog->routine   = routine;                                  
a001a2a4:	e58b502c 	str	r5, [fp, #44]	; 0x2c                          <== NOT EXECUTED
  the_watchdog->id        = id;                                       
a001a2a8:	e58b6030 	str	r6, [fp, #48]	; 0x30                          <== NOT EXECUTED
  the_watchdog->user_data = user_data;                                
a001a2ac:	e58b8034 	str	r8, [fp, #52]	; 0x34                          <== NOT EXECUTED
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
a001a2b0:	e58b701c 	str	r7, [fp, #28]                                 <== NOT EXECUTED
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
a001a2b4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
      _Thread_Enable_dispatch();                                      
a001a2b8:	eb000db0 	bl	a001d980 <_Thread_Enable_dispatch>             <== NOT EXECUTED
      return RTEMS_SUCCESSFUL;                                        
a001a2bc:	e1a00009 	mov	r0, r9                                        <== NOT EXECUTED
a001a2c0:	eaffffdb 	b	a001a234 <rtems_timer_server_fire_when+0x60>    <== NOT EXECUTED
                                                                      

a000ae14 <rtems_verror>: { int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) {
a000ae14:	e3100202 	tst	r0, #536870912	; 0x20000000                   <== NOT EXECUTED
static int rtems_verror(                                              
  rtems_error_code_t  error_flag,                                     
  const char         *printf_format,                                  
  va_list             arglist                                         
)                                                                     
{                                                                     
a000ae18:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a000ae1c:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a000ae20:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
a000ae24:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  int               local_errno = 0;                                  
  int               chars_written = 0;                                
  rtems_status_code status;                                           
                                                                      
  if (error_flag & RTEMS_ERROR_PANIC) {                               
a000ae28:	0a00000d 	beq	a000ae64 <rtems_verror+0x50>                  <== NOT EXECUTED
    if (rtems_panic_in_progress++)                                    
a000ae2c:	e59f212c 	ldr	r2, [pc, #300]	; a000af60 <rtems_verror+0x14c><== NOT EXECUTED
a000ae30:	e5921000 	ldr	r1, [r2]                                      <== NOT EXECUTED
a000ae34:	e2813001 	add	r3, r1, #1                                    <== NOT EXECUTED
a000ae38:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000ae3c:	e5823000 	str	r3, [r2]                                      <== NOT EXECUTED
a000ae40:	0a000004 	beq	a000ae58 <rtems_verror+0x44>                  <== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );                                    
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  _Thread_Dispatch_disable_level += 1;                                
a000ae44:	e59f3118 	ldr	r3, [pc, #280]	; a000af64 <rtems_verror+0x150><== NOT EXECUTED
a000ae48:	e5931000 	ldr	r1, [r3]                                      <== NOT EXECUTED
a000ae4c:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
a000ae50:	e5831000 	str	r1, [r3]                                      <== NOT EXECUTED
  RTEMS_COMPILER_MEMORY_BARRIER();                                    
a000ae54:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
      _Thread_Disable_dispatch();       /* disable task switches */   
                                                                      
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
a000ae58:	e3530002 	cmp	r3, #2                                        <== NOT EXECUTED
      return 0;                                                       
a000ae5c:	c3a06000 	movgt	r6, #0                                      <== NOT EXECUTED
  if (error_flag & RTEMS_ERROR_PANIC) {                               
    if (rtems_panic_in_progress++)                                    
      _Thread_Disable_dispatch();       /* disable task switches */   
                                                                      
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
a000ae60:	ca000024 	bgt	a000aef8 <rtems_verror+0xe4>                  <== NOT EXECUTED
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
a000ae64:	e59f50fc 	ldr	r5, [pc, #252]	; a000af68 <rtems_verror+0x154><== NOT EXECUTED
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
a000ae68:	e3c47207 	bic	r7, r4, #1879048192	; 0x70000000              <== NOT EXECUTED
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
a000ae6c:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000ae70:	e5930008 	ldr	r0, [r3, #8]                                  <== NOT EXECUTED
a000ae74:	eb002f5d 	bl	a0016bf0 <fflush>                              <== NOT EXECUTED
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
a000ae78:	e2144101 	ands	r4, r4, #1073741824	; 0x40000000             <== NOT EXECUTED
a000ae7c:	1a00002a 	bne	a000af2c <rtems_verror+0x118>                 <== NOT EXECUTED
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if (_System_state_Is_multiprocessing)                             
      fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
a000ae80:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000ae84:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000ae88:	e1a01008 	mov	r1, r8                                        <== NOT EXECUTED
a000ae8c:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
a000ae90:	eb004a93 	bl	a001d8e4 <vfprintf>                            <== NOT EXECUTED
                                                                      
  if (status)                                                         
a000ae94:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if (_System_state_Is_multiprocessing)                             
      fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
a000ae98:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  if (status)                                                         
a000ae9c:	1a000017 	bne	a000af00 <rtems_verror+0xec>                  <== NOT EXECUTED
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
a000aea0:	e3540000 	cmp	r4, #0                                        <== NOT EXECUTED
a000aea4:	0a00000b 	beq	a000aed8 <rtems_verror+0xc4>                  <== NOT EXECUTED
    if ((local_errno > 0) && *strerror(local_errno))                  
a000aea8:	da000004 	ble	a000aec0 <rtems_verror+0xac>                  <== NOT EXECUTED
a000aeac:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000aeb0:	eb003337 	bl	a0017b94 <strerror>                            <== NOT EXECUTED
a000aeb4:	e5d03000 	ldrb	r3, [r0]                                     <== NOT EXECUTED
a000aeb8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000aebc:	1a00001d 	bne	a000af38 <rtems_verror+0x124>                 <== NOT EXECUTED
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
a000aec0:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000aec4:	e59f10a0 	ldr	r1, [pc, #160]	; a000af6c <rtems_verror+0x158><== NOT EXECUTED
a000aec8:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000aecc:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
a000aed0:	eb00302c 	bl	a0016f88 <fprintf>                             <== NOT EXECUTED
a000aed4:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
a000aed8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000aedc:	e59f108c 	ldr	r1, [pc, #140]	; a000af70 <rtems_verror+0x15c><== NOT EXECUTED
a000aee0:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
a000aee4:	eb003027 	bl	a0016f88 <fprintf>                             <== NOT EXECUTED
                                                                      
  (void) fflush(stderr);                                              
a000aee8:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
a000aeec:	e0806006 	add	r6, r0, r6                                    <== NOT EXECUTED
                                                                      
  (void) fflush(stderr);                                              
a000aef0:	e593000c 	ldr	r0, [r3, #12]                                 <== NOT EXECUTED
a000aef4:	eb002f3d 	bl	a0016bf0 <fflush>                              <== NOT EXECUTED
                                                                      
  return chars_written;                                               
}                                                                     
a000aef8:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000aefc:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
a000af00:	e59f3060 	ldr	r3, [pc, #96]	; a000af68 <rtems_verror+0x154> <== NOT EXECUTED
a000af04:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000af08:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000af0c:	e593700c 	ldr	r7, [r3, #12]                                 <== NOT EXECUTED
a000af10:	ebffffbb 	bl	a000ae04 <rtems_status_text>                   <== NOT EXECUTED
a000af14:	e59f1058 	ldr	r1, [pc, #88]	; a000af74 <rtems_verror+0x160> <== NOT EXECUTED
a000af18:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000af1c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000af20:	eb003018 	bl	a0016f88 <fprintf>                             <== NOT EXECUTED
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
a000af24:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
a000af28:	eaffffdc 	b	a000aea0 <rtems_verror+0x8c>                    <== NOT EXECUTED
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
    local_errno = errno;                                              
a000af2c:	eb002e38 	bl	a0016814 <__errno>                             <== NOT EXECUTED
a000af30:	e5904000 	ldr	r4, [r0]                                      <== NOT EXECUTED
a000af34:	eaffffd1 	b	a000ae80 <rtems_verror+0x6c>                    <== NOT EXECUTED
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
    if ((local_errno > 0) && *strerror(local_errno))                  
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
a000af38:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a000af3c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000af40:	e593400c 	ldr	r4, [r3, #12]                                 <== NOT EXECUTED
a000af44:	eb003312 	bl	a0017b94 <strerror>                            <== NOT EXECUTED
a000af48:	e59f1028 	ldr	r1, [pc, #40]	; a000af78 <rtems_verror+0x164> <== NOT EXECUTED
a000af4c:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000af50:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000af54:	eb00300b 	bl	a0016f88 <fprintf>                             <== NOT EXECUTED
a000af58:	e0866000 	add	r6, r6, r0                                    <== NOT EXECUTED
a000af5c:	eaffffdd 	b	a000aed8 <rtems_verror+0xc4>                    <== NOT EXECUTED
                                                                      

a000a5e0 <rtems_workspace_allocate>: */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) {
a000a5e0:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  void *ptr;                                                          
                                                                      
  /*                                                                  
   * check the arguments                                              
   */                                                                 
  if ( !pointer )                                                     
a000a5e4:	e2514000 	subs	r4, r1, #0                                   <== NOT EXECUTED
 */                                                                   
bool rtems_workspace_allocate(                                        
  uintptr_t   bytes,                                                  
  void      **pointer                                                 
)                                                                     
{                                                                     
a000a5e8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
  void *ptr;                                                          
                                                                      
  /*                                                                  
   * check the arguments                                              
   */                                                                 
  if ( !pointer )                                                     
a000a5ec:	0a00000c 	beq	a000a624 <rtems_workspace_allocate+0x44>      <== NOT EXECUTED
    return false;                                                     
                                                                      
  if ( !bytes )                                                       
a000a5f0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return false;                                                     
a000a5f4:	01a00000 	moveq	r0, r0                                      <== NOT EXECUTED
   * check the arguments                                              
   */                                                                 
  if ( !pointer )                                                     
    return false;                                                     
                                                                      
  if ( !bytes )                                                       
a000a5f8:	1a000000 	bne	a000a600 <rtems_workspace_allocate+0x20>      <== NOT EXECUTED
  if (!ptr)                                                           
    return false;                                                     
                                                                      
  *pointer = ptr;                                                     
  return true;                                                        
}                                                                     
a000a5fc:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(                  
  Heap_Control *heap,                                                 
  uintptr_t size                                                      
)                                                                     
{                                                                     
  return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
a000a600:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000a604:	e59f0020 	ldr	r0, [pc, #32]	; a000a62c <rtems_workspace_allocate+0x4c><== NOT EXECUTED
a000a608:	e1a03002 	mov	r3, r2                                        <== NOT EXECUTED
a000a60c:	eb000593 	bl	a000bc60 <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
                                                                      
  /*                                                                  
   * Allocate the memory                                              
   */                                                                 
  ptr =  _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes );
  if (!ptr)                                                           
a000a610:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a614:	0afffff8 	beq	a000a5fc <rtems_workspace_allocate+0x1c>      <== NOT EXECUTED
    return false;                                                     
                                                                      
  *pointer = ptr;                                                     
a000a618:	e5840000 	str	r0, [r4]                                      <== NOT EXECUTED
  return true;                                                        
a000a61c:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a000a620:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * check the arguments                                              
   */                                                                 
  if ( !pointer )                                                     
    return false;                                                     
a000a624:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a628:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000a630 <rtems_workspace_free>: * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) {
a000a630:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
   return _Protected_heap_Free( &_Workspace_Area, pointer );          
a000a634:	e59f0000 	ldr	r0, [pc, #0]	; a000a63c <rtems_workspace_free+0xc><== NOT EXECUTED
a000a638:	ea00059b 	b	a000bcac <_Protected_heap_Free>                 <== NOT EXECUTED
                                                                      

a000a5cc <rtems_workspace_get_information>: bool rtems_workspace_get_information( Heap_Information_block *the_info ) { if ( !the_info )
a000a5cc:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
a000a5d0:	012fff1e 	bxeq	lr                                           <== NOT EXECUTED
    return false;                                                     
                                                                      
  return _Protected_heap_Get_information( &_Workspace_Area, the_info );
a000a5d4:	e59f0000 	ldr	r0, [pc, #0]	; a000a5dc <rtems_workspace_get_information+0x10><== NOT EXECUTED
a000a5d8:	ea0005c2 	b	a000bce8 <_Protected_heap_Get_information>      <== NOT EXECUTED
                                                                      

a0006ad8 <scanInt>: /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) {
a0006ad8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006adc:	e59fb0fc 	ldr	fp, [pc, #252]	; a0006be0 <scanInt+0x108>     <== NOT EXECUTED
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
a0006ae0:	e59fa0fc 	ldr	sl, [pc, #252]	; a0006be4 <scanInt+0x10c>     <== NOT EXECUTED
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
a0006ae4:	e59f90fc 	ldr	r9, [pc, #252]	; a0006be8 <scanInt+0x110>     <== NOT EXECUTED
/*                                                                    
 * Extract an integer value from the database                         
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
a0006ae8:	e24dd004 	sub	sp, sp, #4                                    <== NOT EXECUTED
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
a0006aec:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
/*                                                                    
 * Extract an integer value from the database                         
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
a0006af0:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0006af4:	e58d1000 	str	r1, [sp]                                      <== NOT EXECUTED
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
a0006af8:	e3e07102 	mvn	r7, #-2147483648	; 0x80000000                 <== NOT EXECUTED
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
a0006afc:	e1a05006 	mov	r5, r6                                        <== NOT EXECUTED
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
a0006b00:	e3a0800a 	mov	r8, #10                                       <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006b04:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a0006b08:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0006b0c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006b10:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
a0006b14:	ba00001b 	blt	a0006b88 <scanInt+0xb0>                       <== NOT EXECUTED
a0006b18:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a0006b1c:	e4d30001 	ldrb	r0, [r3], #1                                 <== NOT EXECUTED
    if (c == ':')                                                     
a0006b20:	e350003a 	cmp	r0, #58	; 0x3a                                <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006b24:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    if (c == ':')                                                     
a0006b28:	0a00001b 	beq	a0006b9c <scanInt+0xc4>                       <== NOT EXECUTED
      break;                                                          
    if (sign == 0) {                                                  
a0006b2c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a0006b30:	1a000004 	bne	a0006b48 <scanInt+0x70>                       <== NOT EXECUTED
      if (c == '-') {                                                 
a0006b34:	e350002d 	cmp	r0, #45	; 0x2d                                <== NOT EXECUTED
        sign = -1;                                                    
        limit++;                                                      
a0006b38:	02877001 	addeq	r7, r7, #1                                  <== NOT EXECUTED
    c = getc(fp);                                                     
    if (c == ':')                                                     
      break;                                                          
    if (sign == 0) {                                                  
      if (c == '-') {                                                 
        sign = -1;                                                    
a0006b3c:	03e06000 	mvneq	r6, #0                                      <== NOT EXECUTED
  for (;;) {                                                          
    c = getc(fp);                                                     
    if (c == ':')                                                     
      break;                                                          
    if (sign == 0) {                                                  
      if (c == '-') {                                                 
a0006b40:	0affffef 	beq	a0006b04 <scanInt+0x2c>                       <== NOT EXECUTED
        sign = -1;                                                    
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
a0006b44:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
    }                                                                 
    if (!isdigit(c))                                                  
a0006b48:	e59a3000 	ldr	r3, [sl]                                      <== NOT EXECUTED
a0006b4c:	e0833000 	add	r3, r3, r0                                    <== NOT EXECUTED
a0006b50:	e5d33001 	ldrb	r3, [r3, #1]                                 <== NOT EXECUTED
a0006b54:	e2133004 	ands	r3, r3, #4                                   <== NOT EXECUTED
a0006b58:	0a00001e 	beq	a0006bd8 <scanInt+0x100>                      <== NOT EXECUTED
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
a0006b5c:	e0832799 	umull	r2, r3, r9, r7                              <== NOT EXECUTED
a0006b60:	e15501a3 	cmp	r5, r3, lsr #3                                <== NOT EXECUTED
a0006b64:	8a000018 	bhi	a0006bcc <scanInt+0xf4>                       <== NOT EXECUTED
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
a0006b68:	e2400030 	sub	r0, r0, #48	; 0x30                            <== NOT EXECUTED
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
a0006b6c:	0a000012 	beq	a0006bbc <scanInt+0xe4>                       <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006b70:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
a0006b74:	e0250598 	mla	r5, r8, r5, r0                                <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006b78:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0006b7c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006b80:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
a0006b84:	aaffffe3 	bge	a0006b18 <scanInt+0x40>                       <== NOT EXECUTED
a0006b88:	e59b0000 	ldr	r0, [fp]                                      <== NOT EXECUTED
a0006b8c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006b90:	eb0032dc 	bl	a0013708 <__srget_r>                           <== NOT EXECUTED
    if (c == ':')                                                     
a0006b94:	e350003a 	cmp	r0, #58	; 0x3a                                <== NOT EXECUTED
a0006b98:	1affffe3 	bne	a0006b2c <scanInt+0x54>                       <== NOT EXECUTED
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
  }                                                                   
  if (sign == 0)                                                      
a0006b9c:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
    return 0;                                                         
a0006ba0:	01a00006 	moveq	r0, r6                                      <== NOT EXECUTED
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
      return 0;                                                       
    i = i * 10 + d;                                                   
  }                                                                   
  if (sign == 0)                                                      
a0006ba4:	0a000009 	beq	a0006bd0 <scanInt+0xf8>                       <== NOT EXECUTED
    return 0;                                                         
  *val = i * sign;                                                    
a0006ba8:	e0050596 	mul	r5, r6, r5                                    <== NOT EXECUTED
a0006bac:	e59d3000 	ldr	r3, [sp]                                      <== NOT EXECUTED
  return 1;                                                           
a0006bb0:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
      return 0;                                                       
    i = i * 10 + d;                                                   
  }                                                                   
  if (sign == 0)                                                      
    return 0;                                                         
  *val = i * sign;                                                    
a0006bb4:	e5835000 	str	r5, [r3]                                      <== NOT EXECUTED
  return 1;                                                           
a0006bb8:	ea000004 	b	a0006bd0 <scanInt+0xf8>                         <== NOT EXECUTED
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
a0006bbc:	e0030598 	mul	r3, r8, r5                                    <== NOT EXECUTED
a0006bc0:	e0633007 	rsb	r3, r3, r7                                    <== NOT EXECUTED
a0006bc4:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a0006bc8:	9affffe8 	bls	a0006b70 <scanInt+0x98>                       <== NOT EXECUTED
      return 0;                                                       
a0006bcc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  if (sign == 0)                                                      
    return 0;                                                         
  *val = i * sign;                                                    
  return 1;                                                           
}                                                                     
a0006bd0:	e28dd004 	add	sp, sp, #4                                    <== NOT EXECUTED
a0006bd4:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          <== NOT EXECUTED
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
a0006bd8:	e1a00003 	mov	r0, r3                                        <== NOT EXECUTED
a0006bdc:	eafffffb 	b	a0006bd0 <scanInt+0xf8>                         <== NOT EXECUTED
                                                                      

a0006bec <scanString>: /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) {
a0006bec:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0006bf0:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
a0006bf4:	e5922000 	ldr	r2, [r2]                                      <== NOT EXECUTED
/*                                                                    
 * Extract a string value from the database                           
 */                                                                   
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
a0006bf8:	e59d7018 	ldr	r7, [sp, #24]                                 <== NOT EXECUTED
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006bfc:	e59f60d8 	ldr	r6, [pc, #216]	; a0006cdc <scanString+0xf0>   <== NOT EXECUTED
/*                                                                    
 * Extract a string value from the database                           
 */                                                                   
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
a0006c00:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
a0006c04:	e1a08003 	mov	r8, r3                                        <== NOT EXECUTED
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
a0006c08:	e5812000 	str	r2, [r1]                                      <== NOT EXECUTED
a0006c0c:	ea000013 	b	a0006c60 <scanString+0x74>                      <== NOT EXECUTED
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006c10:	e5943000 	ldr	r3, [r4]                                      <== NOT EXECUTED
a0006c14:	e4d30001 	ldrb	r0, [r3], #1                                 <== NOT EXECUTED
    if (c == ':') {                                                   
a0006c18:	e350003a 	cmp	r0, #58	; 0x3a                                <== NOT EXECUTED
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006c1c:	e5843000 	str	r3, [r4]                                      <== NOT EXECUTED
    if (c == ':') {                                                   
a0006c20:	0a000018 	beq	a0006c88 <scanString+0x9c>                    <== NOT EXECUTED
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
a0006c24:	e350000a 	cmp	r0, #10                                       <== NOT EXECUTED
a0006c28:	0a000025 	beq	a0006cc4 <scanString+0xd8>                    <== NOT EXECUTED
        if (!nlFlag)                                                  
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
a0006c2c:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
a0006c30:	0a000021 	beq	a0006cbc <scanString+0xd0>                    <== NOT EXECUTED
      return 0;                                                       
    if (*nleft < 2)                                                   
a0006c34:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
a0006c38:	e3530001 	cmp	r3, #1                                        <== NOT EXECUTED
a0006c3c:	9a000024 	bls	a0006cd4 <scanString+0xe8>                    <== NOT EXECUTED
      return 0;                                                       
    **bufp = c;                                                       
a0006c40:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0006c44:	e5c30000 	strb	r0, [r3]                                     <== NOT EXECUTED
    ++(*bufp);                                                        
a0006c48:	e5952000 	ldr	r2, [r5]                                      <== NOT EXECUTED
    --(*nleft);                                                       
a0006c4c:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
a0006c50:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
    --(*nleft);                                                       
a0006c54:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
a0006c58:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
    --(*nleft);                                                       
a0006c5c:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
a0006c60:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a0006c64:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
a0006c68:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006c6c:	e5843004 	str	r3, [r4, #4]                                  <== NOT EXECUTED
a0006c70:	aaffffe6 	bge	a0006c10 <scanString+0x24>                    <== NOT EXECUTED
a0006c74:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a0006c78:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0006c7c:	eb0032a1 	bl	a0013708 <__srget_r>                           <== NOT EXECUTED
    if (c == ':') {                                                   
a0006c80:	e350003a 	cmp	r0, #58	; 0x3a                                <== NOT EXECUTED
a0006c84:	1affffe6 	bne	a0006c24 <scanString+0x38>                    <== NOT EXECUTED
        if (nlFlag)                                                   
a0006c88:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0006c8c:	1a00000a 	bne	a0006cbc <scanString+0xd0>                    <== NOT EXECUTED
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
a0006c90:	e5953000 	ldr	r3, [r5]                                      <== NOT EXECUTED
a0006c94:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
  ++(*bufp);                                                          
  --(*nleft);                                                         
  return 1;                                                           
a0006c98:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
a0006c9c:	e5c32000 	strb	r2, [r3]                                     <== NOT EXECUTED
  ++(*bufp);                                                          
a0006ca0:	e5952000 	ldr	r2, [r5]                                      <== NOT EXECUTED
  --(*nleft);                                                         
a0006ca4:	e5983000 	ldr	r3, [r8]                                      <== NOT EXECUTED
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
a0006ca8:	e0822000 	add	r2, r2, r0                                    <== NOT EXECUTED
  --(*nleft);                                                         
a0006cac:	e2433001 	sub	r3, r3, #1                                    <== NOT EXECUTED
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
a0006cb0:	e5852000 	str	r2, [r5]                                      <== NOT EXECUTED
  --(*nleft);                                                         
a0006cb4:	e5883000 	str	r3, [r8]                                      <== NOT EXECUTED
  return 1;                                                           
a0006cb8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
        if (!nlFlag)                                                  
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
      return 0;                                                       
a0006cbc:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0006cc0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
        if (!nlFlag)                                                  
a0006cc4:	e3570000 	cmp	r7, #0                                        <== NOT EXECUTED
a0006cc8:	1afffff0 	bne	a0006c90 <scanString+0xa4>                    <== NOT EXECUTED
            return 0;                                                 
a0006ccc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006cd0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
a0006cd4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
  --(*nleft);                                                         
  return 1;                                                           
}                                                                     
a0006cd8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
                                                                      

a0006ce0 <scangr>: FILE *fp, struct group *grp, char *buffer, size_t bufsize ) {
a0006ce0:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0006ce4:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
a0006ce8:	e28d5008 	add	r5, sp, #8                                    <== NOT EXECUTED
a0006cec:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
a0006cf0:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a0006cf4:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
a0006cf8:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0006cfc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006d00:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
a0006d04:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0006d08:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
a0006d0c:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006d10:	ebffffb5 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006d14:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006d18:	1a000001 	bne	a0006d24 <scangr+0x44>                        <== NOT EXECUTED
      grp->gr_mem[memcount++] = cp + 1;                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
  return 1;                                                           
}                                                                     
a0006d1c:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a0006d20:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
a0006d24:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006d28:	e2881004 	add	r1, r8, #4                                    <== NOT EXECUTED
a0006d2c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006d30:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006d34:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006d38:	ebffffab 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006d3c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006d40:	0afffff5 	beq	a0006d1c <scangr+0x3c>                        <== NOT EXECUTED
   || !scanInt(fp, &grgid)                                            
a0006d44:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006d48:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
a0006d4c:	ebffff61 	bl	a0006ad8 <scanInt>                             <== NOT EXECUTED
a0006d50:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006d54:	0afffff0 	beq	a0006d1c <scangr+0x3c>                        <== NOT EXECUTED
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
a0006d58:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
a0006d5c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006d60:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
a0006d64:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006d68:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006d6c:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006d70:	ebffff9d 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006d74:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006d78:	0affffe7 	beq	a0006d1c <scangr+0x3c>                        <== NOT EXECUTED
    return 0;                                                         
  grp->gr_gid = grgid;                                                
a0006d7c:	e1dd31b0 	ldrh	r3, [sp, #16]                                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006d80:	e59d100c 	ldr	r1, [sp, #12]                                 <== NOT EXECUTED
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
   || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)          
   || !scanInt(fp, &grgid)                                            
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
    return 0;                                                         
  grp->gr_gid = grgid;                                                
a0006d84:	e1c830b8 	strh	r3, [r8, #8]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006d88:	e5d13000 	ldrb	r3, [r1]                                     <== NOT EXECUTED
a0006d8c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006d90:	03a06017 	moveq	r6, #23                                     <== NOT EXECUTED
a0006d94:	0a000007 	beq	a0006db8 <scangr+0xd8>                        <== NOT EXECUTED
a0006d98:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
    if(*cp == ',')                                                    
a0006d9c:	e353002c 	cmp	r3, #44	; 0x2c                                <== NOT EXECUTED
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006da0:	e5f23001 	ldrb	r3, [r2, #1]!                                <== NOT EXECUTED
    if(*cp == ',')                                                    
      memcount++;                                                     
a0006da4:	02866001 	addeq	r6, r6, #1                                  <== NOT EXECUTED
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006da8:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006dac:	1afffffa 	bne	a0006d9c <scangr+0xbc>                        <== NOT EXECUTED
a0006db0:	e1a06106 	lsl	r6, r6, #2                                    <== NOT EXECUTED
a0006db4:	e2866013 	add	r6, r6, #19                                   <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
a0006db8:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a0006dbc:	e1530006 	cmp	r3, r6                                        <== NOT EXECUTED
    return 0;                                                         
a0006dc0:	33a00000 	movcc	r0, #0                                      <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
a0006dc4:	3affffd4 	bcc	a0006d1c <scangr+0x3c>                        <== NOT EXECUTED
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
a0006dc8:	e59d0008 	ldr	r0, [sp, #8]                                  <== NOT EXECUTED
a0006dcc:	e280000f 	add	r0, r0, #15                                   <== NOT EXECUTED
a0006dd0:	e3c0000f 	bic	r0, r0, #15                                   <== NOT EXECUTED
a0006dd4:	e588000c 	str	r0, [r8, #12]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
a0006dd8:	e5801000 	str	r1, [r0]                                      <== NOT EXECUTED
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006ddc:	e59d200c 	ldr	r2, [sp, #12]                                 <== NOT EXECUTED
a0006de0:	e5d23000 	ldrb	r3, [r2]                                     <== NOT EXECUTED
a0006de4:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006de8:	0a000010 	beq	a0006e30 <scangr+0x150>                       <== NOT EXECUTED
}                                                                     
                                                                      
/*                                                                    
 * Extract a single group record from the database                    
 */                                                                   
static int scangr(                                                    
a0006dec:	e2822001 	add	r2, r2, #1                                    <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006df0:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
a0006df4:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
    if(*cp == ',') {                                                  
a0006df8:	e353002c 	cmp	r3, #44	; 0x2c                                <== NOT EXECUTED
      *cp = '\0';                                                     
a0006dfc:	05420001 	strbeq	r0, [r2, #-1]                              <== NOT EXECUTED
      grp->gr_mem[memcount++] = cp + 1;                               
a0006e00:	0598300c 	ldreq	r3, [r8, #12]                               <== NOT EXECUTED
a0006e04:	07832101 	streq	r2, [r3, r1, lsl #2]                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006e08:	e4d23001 	ldrb	r3, [r2], #1                                 <== NOT EXECUTED
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
      grp->gr_mem[memcount++] = cp + 1;                               
a0006e0c:	02811001 	addeq	r1, r1, #1                                  <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006e10:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0006e14:	1afffff7 	bne	a0006df8 <scangr+0x118>                       <== NOT EXECUTED
a0006e18:	e598000c 	ldr	r0, [r8, #12]                                 <== NOT EXECUTED
a0006e1c:	e1a01101 	lsl	r1, r1, #2                                    <== NOT EXECUTED
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
      grp->gr_mem[memcount++] = cp + 1;                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
a0006e20:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a0006e24:	e7803001 	str	r3, [r0, r1]                                  <== NOT EXECUTED
  return 1;                                                           
a0006e28:	e3a00001 	mov	r0, #1                                        <== NOT EXECUTED
a0006e2c:	eaffffba 	b	a0006d1c <scangr+0x3c>                          <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
a0006e30:	e3a01004 	mov	r1, #4                                        <== NOT EXECUTED
a0006e34:	eafffff9 	b	a0006e20 <scangr+0x140>                         <== NOT EXECUTED
                                                                      

a0006e38 <scanpw>: FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) {
a0006e38:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
a0006e3c:	e24dd014 	sub	sp, sp, #20                                   <== NOT EXECUTED
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
a0006e40:	e28d5008 	add	r5, sp, #8                                    <== NOT EXECUTED
a0006e44:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
a0006e48:	e58d2008 	str	r2, [sp, #8]                                  <== NOT EXECUTED
a0006e4c:	e58d3004 	str	r3, [sp, #4]                                  <== NOT EXECUTED
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
a0006e50:	e3a06000 	mov	r6, #0                                        <== NOT EXECUTED
a0006e54:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006e58:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
a0006e5c:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
a0006e60:	e1a08001 	mov	r8, r1                                        <== NOT EXECUTED
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
a0006e64:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006e68:	ebffff5f 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006e6c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006e70:	1a000001 	bne	a0006e7c <scanpw+0x44>                        <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
  pwd->pw_gid = pwgid;                                                
  return 1;                                                           
}                                                                     
a0006e74:	e28dd014 	add	sp, sp, #20                                   <== NOT EXECUTED
a0006e78:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
)                                                                     
{                                                                     
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
   || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)          
a0006e7c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006e80:	e2881004 	add	r1, r8, #4                                    <== NOT EXECUTED
a0006e84:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006e88:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006e8c:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006e90:	ebffff55 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006e94:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006e98:	0afffff5 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanInt(fp, &pwuid)                                            
a0006e9c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006ea0:	e28d1010 	add	r1, sp, #16                                   <== NOT EXECUTED
a0006ea4:	ebffff0b 	bl	a0006ad8 <scanInt>                             <== NOT EXECUTED
a0006ea8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006eac:	0afffff0 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanInt(fp, &pwgid)                                            
a0006eb0:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006eb4:	e28d100c 	add	r1, sp, #12                                   <== NOT EXECUTED
a0006eb8:	ebffff06 	bl	a0006ad8 <scanInt>                             <== NOT EXECUTED
a0006ebc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006ec0:	0affffeb 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
a0006ec4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006ec8:	e288100c 	add	r1, r8, #12                                   <== NOT EXECUTED
a0006ecc:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006ed0:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006ed4:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006ed8:	ebffff43 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006edc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006ee0:	0affffe3 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
a0006ee4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006ee8:	e2881010 	add	r1, r8, #16                                   <== NOT EXECUTED
a0006eec:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006ef0:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006ef4:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006ef8:	ebffff3b 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006efc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006f00:	0affffdb 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
a0006f04:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006f08:	e2881014 	add	r1, r8, #20                                   <== NOT EXECUTED
a0006f0c:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006f10:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006f14:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006f18:	ebffff33 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006f1c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0006f20:	0affffd3 	beq	a0006e74 <scanpw+0x3c>                        <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
a0006f24:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0006f28:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
a0006f2c:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a0006f30:	e2881018 	add	r1, r8, #24                                   <== NOT EXECUTED
a0006f34:	e1a02005 	mov	r2, r5                                        <== NOT EXECUTED
a0006f38:	e58d6000 	str	r6, [sp]                                      <== NOT EXECUTED
a0006f3c:	ebffff2a 	bl	a0006bec <scanString>                          <== NOT EXECUTED
a0006f40:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
a0006f44:	11dd31b0 	ldrhne	r3, [sp, #16]                              <== NOT EXECUTED
  pwd->pw_gid = pwgid;                                                
  return 1;                                                           
a0006f48:	11a00006 	movne	r0, r6                                      <== NOT EXECUTED
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
a0006f4c:	11c830b8 	strhne	r3, [r8, #8]                               <== NOT EXECUTED
  pwd->pw_gid = pwgid;                                                
a0006f50:	11dd30bc 	ldrhne	r3, [sp, #12]                              <== NOT EXECUTED
a0006f54:	11c830ba 	strhne	r3, [r8, #10]                              <== NOT EXECUTED
  return 1;                                                           
a0006f58:	eaffffc5 	b	a0006e74 <scanpw+0x3c>                          <== NOT EXECUTED
                                                                      

a000931c <seteuid>: #include <rtems/userenv.h> int seteuid( uid_t euid ) { _POSIX_types_Euid = euid;
a000931c:	e59f300c 	ldr	r3, [pc, #12]	; a0009330 <seteuid+0x14>       <== NOT EXECUTED
a0009320:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0009324:	e1c303b6 	strh	r0, [r3, #54]	; 0x36                         <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0009328:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000932c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00082f4 <setgid>: */ int setgid( gid_t gid ) { _POSIX_types_Gid = gid;
a00082f4:	e59f300c 	ldr	r3, [pc, #12]	; a0008308 <setgid+0x14>        <== NOT EXECUTED
a00082f8:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a00082fc:	e1c303b4 	strh	r0, [r3, #52]	; 0x34                         <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0008300:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0008304:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000748c <setgrent>: void setgrent(void) {
a000748c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  init_etc_passwd_group();                                            
                                                                      
  if (group_fp != NULL)                                               
a0007490:	e59f4024 	ldr	r4, [pc, #36]	; a00074bc <setgrent+0x30>      <== NOT EXECUTED
  return &grent;                                                      
}                                                                     
                                                                      
void setgrent(void)                                                   
{                                                                     
  init_etc_passwd_group();                                            
a0007494:	ebfffeb0 	bl	a0006f5c <init_etc_passwd_group>               <== NOT EXECUTED
                                                                      
  if (group_fp != NULL)                                               
a0007498:	e59401c4 	ldr	r0, [r4, #452]	; 0x1c4                        <== NOT EXECUTED
a000749c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a00074a0:	0a000000 	beq	a00074a8 <setgrent+0x1c>                      <== NOT EXECUTED
    fclose(group_fp);                                                 
a00074a4:	eb002b67 	bl	a0012248 <fclose>                              <== NOT EXECUTED
  group_fp = fopen("/etc/group", "r");                                
a00074a8:	e59f0010 	ldr	r0, [pc, #16]	; a00074c0 <setgrent+0x34>      <== NOT EXECUTED
a00074ac:	e59f1010 	ldr	r1, [pc, #16]	; a00074c4 <setgrent+0x38>      <== NOT EXECUTED
a00074b0:	eb002d3b 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a00074b4:	e58401c4 	str	r0, [r4, #452]	; 0x1c4                        <== NOT EXECUTED
}                                                                     
a00074b8:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a000830c <setpgid>: int setpgid( pid_t pid __attribute__((unused)), pid_t pgid __attribute__((unused)) ) {
a000830c:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( ENOSYS );                     
a0008310:	eb00277e 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a0008314:	e3a03058 	mov	r3, #88	; 0x58                                <== NOT EXECUTED
a0008318:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
}                                                                     
a000831c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0008320:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0007318 <setpwent>: void setpwent(void) {
a0007318:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  init_etc_passwd_group();                                            
                                                                      
  if (passwd_fp != NULL)                                              
a000731c:	e59f4024 	ldr	r4, [pc, #36]	; a0007348 <setpwent+0x30>      <== NOT EXECUTED
  return &pwent;                                                      
}                                                                     
                                                                      
void setpwent(void)                                                   
{                                                                     
  init_etc_passwd_group();                                            
a0007320:	ebffff0d 	bl	a0006f5c <init_etc_passwd_group>               <== NOT EXECUTED
                                                                      
  if (passwd_fp != NULL)                                              
a0007324:	e59400e8 	ldr	r0, [r4, #232]	; 0xe8                         <== NOT EXECUTED
a0007328:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000732c:	0a000000 	beq	a0007334 <setpwent+0x1c>                      <== NOT EXECUTED
    fclose(passwd_fp);                                                
a0007330:	eb002bc4 	bl	a0012248 <fclose>                              <== NOT EXECUTED
  passwd_fp = fopen("/etc/passwd", "r");                              
a0007334:	e59f0010 	ldr	r0, [pc, #16]	; a000734c <setpwent+0x34>      <== NOT EXECUTED
a0007338:	e59f1010 	ldr	r1, [pc, #16]	; a0007350 <setpwent+0x38>      <== NOT EXECUTED
a000733c:	eb002d98 	bl	a00129a4 <fopen>                               <== NOT EXECUTED
a0007340:	e58400e8 	str	r0, [r4, #232]	; 0xe8                         <== NOT EXECUTED
}                                                                     
a0007344:	e8bd8010 	pop	{r4, pc}                                      <== NOT EXECUTED
                                                                      

a0008324 <setsid>: * * 4.3.2 Create Session and Set Process Group ID, P1003.1b-1993, p. 88 */ pid_t setsid( void ) {
a0008324:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  rtems_set_errno_and_return_minus_one( EPERM );                      
a0008328:	eb002778 	bl	a0012110 <__errno>                             <== NOT EXECUTED
a000832c:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0008330:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
}                                                                     
a0008334:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0008338:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000833c <setuid>: */ int setuid( uid_t uid ) { _POSIX_types_Uid = uid;
a000833c:	e59f300c 	ldr	r3, [pc, #12]	; a0008350 <setuid+0x14>        <== NOT EXECUTED
a0008340:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a0008344:	e1c303b2 	strh	r0, [r3, #50]	; 0x32                         <== NOT EXECUTED
  return 0;                                                           
}                                                                     
a0008348:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a000834c:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a00084f0 <siproc>: int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
a00084f0:	e591203c 	ldr	r2, [r1, #60]	; 0x3c                          <== NOT EXECUTED
a00084f4:	e3a03ee7 	mov	r3, #3696	; 0xe70                             <== NOT EXECUTED
a00084f8:	e2833008 	add	r3, r3, #8                                    <== NOT EXECUTED
a00084fc:	e0023003 	and	r3, r2, r3                                    <== NOT EXECUTED
a0008500:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
/*                                                                    
 * Process input character, with semaphore.                           
 */                                                                   
static int                                                            
siproc (unsigned char c, struct rtems_termios_tty *tty)               
{                                                                     
a0008504:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a0008508:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
a000850c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
  int i;                                                              
                                                                      
  /*                                                                  
   * Obtain output semaphore if character will be echoed              
   */                                                                 
  if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
a0008510:	1a000001 	bne	a000851c <siproc+0x2c>                        <== NOT EXECUTED
  }                                                                   
  else {                                                              
    i = iproc (c, tty);                                               
  }                                                                   
  return i;                                                           
}                                                                     
a0008514:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 
    i = iproc (c, tty);                                               
    rtems_semaphore_release (tty->osem);                              
  }                                                                   
  else {                                                              
    i = iproc (c, tty);                                               
a0008518:	eaffff7d 	b	a0008314 <iproc>                                <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Obtain output semaphore if character will be echoed              
   */                                                                 
  if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
    rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 
a000851c:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a0008520:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
a0008524:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a0008528:	eb00054f 	bl	a0009a6c <rtems_semaphore_obtain>              <== NOT EXECUTED
    i = iproc (c, tty);                                               
a000852c:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a0008530:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0008534:	ebffff76 	bl	a0008314 <iproc>                               <== NOT EXECUTED
a0008538:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
    rtems_semaphore_release (tty->osem);                              
a000853c:	e5940018 	ldr	r0, [r4, #24]                                 <== NOT EXECUTED
a0008540:	eb000592 	bl	a0009b90 <rtems_semaphore_release>             <== NOT EXECUTED
  }                                                                   
  else {                                                              
    i = iproc (c, tty);                                               
  }                                                                   
  return i;                                                           
}                                                                     
a0008544:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0008548:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a0007318 <stat>: int _STAT_NAME( const char *path, struct stat *buf ) {
a0007318:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
a000731c:	e2515000 	subs	r5, r1, #0                                   <== NOT EXECUTED
                                                                      
int _STAT_NAME(                                                       
  const char  *path,                                                  
  struct stat *buf                                                    
)                                                                     
{                                                                     
a0007320:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0007324:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
a0007328:	0a000019 	beq	a0007394 <stat+0x7c>                          <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
a000732c:	eb0023ac 	bl	a00101e4 <strlen>                              <== NOT EXECUTED
a0007330:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0007334:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0007338:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000733c:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0007340:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0007344:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0007348:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000734c:	ebfffc19 	bl	a00063b8 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
a0007350:	e2501000 	subs	r1, r0, #0                                   <== NOT EXECUTED
    return -1;                                                        
a0007354:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
  if ( !buf )                                                         
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  status = rtems_filesystem_evaluate_path( path, strlen( path ),      
                                           0, &loc, _STAT_FOLLOW_LINKS );
  if ( status != 0 )                                                  
a0007358:	1a00000a 	bne	a0007388 <stat+0x70>                          <== NOT EXECUTED
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
                                                                      
  memset( buf, 0, sizeof(struct stat) );                              
a000735c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0007360:	e3a02048 	mov	r2, #72	; 0x48                                <== NOT EXECUTED
a0007364:	eb002294 	bl	a000fdbc <memset>                              <== NOT EXECUTED
                                                                      
  status =  (*loc.handlers->fstat_h)( &loc, buf );                    
a0007368:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a000736c:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0007370:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007374:	e5933018 	ldr	r3, [r3, #24]                                 <== NOT EXECUTED
a0007378:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000737c:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0007380:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0007384:	ebfffc45 	bl	a00064a0 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return status;                                                      
}                                                                     
a0007388:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000738c:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0007390:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
                                                                      
  if ( !buf )                                                         
    rtems_set_errno_and_return_minus_one( EFAULT );                   
a0007394:	eb002023 	bl	a000f428 <__errno>                             <== NOT EXECUTED
a0007398:	e3a0300e 	mov	r3, #14                                       <== NOT EXECUTED
a000739c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00073a0:	e3e05000 	mvn	r5, #0                                        <== NOT EXECUTED
a00073a4:	eafffff7 	b	a0007388 <stat+0x70>                            <== NOT EXECUTED
                                                                      

a0009bbc <statvfs>: #include <sys/statvfs.h> int statvfs (const char *path, struct statvfs *sb) {
a0009bbc:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0009bc0:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a0009bc4:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a0009bc8:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
   *    The root node of the mounted filesytem.                       
   *    The node for the directory that the fileystem is mounted on.  
   *    The mount entry that is being refered to.                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
a0009bcc:	eb0030ba 	bl	a0015ebc <strlen>                              <== NOT EXECUTED
a0009bd0:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a0009bd4:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a0009bd8:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a0009bdc:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a0009be0:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a0009be4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a0009be8:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a0009bec:	ebfffab2 	bl	a00086bc <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a0009bf0:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
a0009bf4:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
   *    The root node of the mounted filesytem.                       
   *    The node for the directory that the fileystem is mounted on.  
   *    The mount entry that is being refered to.                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
a0009bf8:	1a000018 	bne	a0009c60 <statvfs+0xa4>                       <== NOT EXECUTED
    return -1;                                                        
                                                                      
  mt_entry      = loc.mt_entry;                                       
  fs_mount_root = &mt_entry->mt_fs_root;                              
                                                                      
  memset (sb, 0, sizeof (struct statvfs));                            
a0009bfc:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a0009c00:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c04:	e2833004 	add	r3, r3, #4                                    <== NOT EXECUTED
a0009c08:	e5850004 	str	r0, [r5, #4]                                  <== NOT EXECUTED
a0009c0c:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c10:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c14:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c18:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c1c:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c20:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c24:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c28:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c2c:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c30:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
   */                                                                 
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
    return -1;                                                        
                                                                      
  mt_entry      = loc.mt_entry;                                       
a0009c34:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
  fs_mount_root = &mt_entry->mt_fs_root;                              
                                                                      
  memset (sb, 0, sizeof (struct statvfs));                            
a0009c38:	e4830004 	str	r0, [r3], #4                                  <== NOT EXECUTED
a0009c3c:	e5830000 	str	r0, [r3]                                      <== NOT EXECUTED
                                                                      
  result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );    
a0009c40:	e5923028 	ldr	r3, [r2, #40]	; 0x28                          <== NOT EXECUTED
a0009c44:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a0009c48:	e282001c 	add	r0, r2, #28                                   <== NOT EXECUTED
a0009c4c:	e5933044 	ldr	r3, [r3, #68]	; 0x44                          <== NOT EXECUTED
a0009c50:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0009c54:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a0009c58:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a0009c5c:	ebfffad0 	bl	a00087a4 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a0009c60:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009c64:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a0009c68:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a0009414 <symlink>: int symlink( const char *actualpath, const char *sympath ) {
a0009414:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a0009418:	e24dd01c 	sub	sp, sp, #28                                   <== NOT EXECUTED
a000941c:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
a0009420:	e1a0200d 	mov	r2, sp                                        <== NOT EXECUTED
                                                                      
int symlink(                                                          
  const char *actualpath,                                             
  const char *sympath                                                 
)                                                                     
{                                                                     
a0009424:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
a0009428:	e1a00001 	mov	r0, r1                                        <== NOT EXECUTED
a000942c:	e28d1018 	add	r1, sp, #24                                   <== NOT EXECUTED
a0009430:	ebffffbf 	bl	a0009334 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
                                                                      
  result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
a0009434:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0009438:	e59d0018 	ldr	r0, [sp, #24]                                 <== NOT EXECUTED
a000943c:	e1a0100d 	mov	r1, sp                                        <== NOT EXECUTED
a0009440:	e5933004 	ldr	r3, [r3, #4]                                  <== NOT EXECUTED
a0009444:	e0850000 	add	r0, r5, r0                                    <== NOT EXECUTED
a0009448:	e28d2014 	add	r2, sp, #20                                   <== NOT EXECUTED
a000944c:	e12fff33 	blx	r3                                            <== NOT EXECUTED
  if ( result != 0 )                                                  
a0009450:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t    loc;                            
  int                                 i;                              
  const char                         *name_start;                     
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
a0009454:	e1a0400d 	mov	r4, sp                                        <== NOT EXECUTED
                                                                      
  result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
  if ( result != 0 )                                                  
    return -1;                                                        
a0009458:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
  int                                 result;                         
                                                                      
  rtems_filesystem_get_start_loc( sympath, &i, &loc );                
                                                                      
  result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
  if ( result != 0 )                                                  
a000945c:	1a000008 	bne	a0009484 <symlink+0x70>                       <== NOT EXECUTED
    return -1;                                                        
                                                                      
  result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);      
a0009460:	e59d300c 	ldr	r3, [sp, #12]                                 <== NOT EXECUTED
a0009464:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0009468:	e1a01006 	mov	r1, r6                                        <== NOT EXECUTED
a000946c:	e5933038 	ldr	r3, [r3, #56]	; 0x38                          <== NOT EXECUTED
a0009470:	e59d2014 	ldr	r2, [sp, #20]                                 <== NOT EXECUTED
a0009474:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a0009478:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a000947c:	e1a0000d 	mov	r0, sp                                        <== NOT EXECUTED
a0009480:	ebfffab1 	bl	a0007f4c <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a0009484:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a0009488:	e28dd01c 	add	sp, sp, #28                                   <== NOT EXECUTED
a000948c:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a00086a8 <sync>: { /* * Walk the one used initially by RTEMS. */ _fwalk(_global_impure_ptr, sync_wrapper);
a00086a8:	e59f3018 	ldr	r3, [pc, #24]	; a00086c8 <sync+0x20>          <== NOT EXECUTED
 * We have to extern it here.                                         
 */                                                                   
extern struct _reent * const _global_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
                                                                      
void sync(void)                                                       
{                                                                     
a00086ac:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Walk the one used initially by RTEMS.                           
   */                                                                 
  _fwalk(_global_impure_ptr, sync_wrapper);                           
a00086b0:	e5930000 	ldr	r0, [r3]                                      <== NOT EXECUTED
a00086b4:	e59f1010 	ldr	r1, [pc, #16]	; a00086cc <sync+0x24>          <== NOT EXECUTED
a00086b8:	eb002a9f 	bl	a001313c <_fwalk>                              <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Now walk all the per-thread reentrancy structures.              
   */                                                                 
  rtems_iterate_over_all_threads(sync_per_thread);                    
a00086bc:	e59f000c 	ldr	r0, [pc, #12]	; a00086d0 <sync+0x28>          <== NOT EXECUTED
}                                                                     
a00086c0:	e49de004 	pop	{lr}		; (ldr lr, [sp], #4)                    <== NOT EXECUTED
   */                                                                 
                                                                      
  /*                                                                  
   *  Now walk all the per-thread reentrancy structures.              
   */                                                                 
  rtems_iterate_over_all_threads(sync_per_thread);                    
a00086c4:	ea000ed8 	b	a000c22c <rtems_iterate_over_all_threads>       <== NOT EXECUTED
                                                                      

a000864c <sync_per_thread>: /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent;
a000864c:	e59030f0 	ldr	r3, [r0, #240]	; 0xf0                         <== NOT EXECUTED
  fdatasync(fn);                                                      
}                                                                     
                                                                      
/* iterate over all FILE *'s for this thread */                       
static void sync_per_thread(Thread_Control *t)                        
{                                                                     
a0008650:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
   /*                                                                 
    *  The sync_wrapper() function will operate on the current thread's
    *  reent structure so we will temporarily use that.               
    */                                                                
   this_reent = t->libc_reent;                                        
   if ( this_reent ) {                                                
a0008654:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a0008658:	0a000008 	beq	a0008680 <sync_per_thread+0x34>               <== NOT EXECUTED
     current_reent = _Thread_Executing->libc_reent;                   
a000865c:	e59f4020 	ldr	r4, [pc, #32]	; a0008684 <sync_per_thread+0x38><== NOT EXECUTED
     _Thread_Executing->libc_reent = this_reent;                      
     _fwalk (t->libc_reent, sync_wrapper);                            
a0008660:	e59f1020 	ldr	r1, [pc, #32]	; a0008688 <sync_per_thread+0x3c><== NOT EXECUTED
    *  The sync_wrapper() function will operate on the current thread's
    *  reent structure so we will temporarily use that.               
    */                                                                
   this_reent = t->libc_reent;                                        
   if ( this_reent ) {                                                
     current_reent = _Thread_Executing->libc_reent;                   
a0008664:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a0008668:	e59250f0 	ldr	r5, [r2, #240]	; 0xf0                         <== NOT EXECUTED
     _Thread_Executing->libc_reent = this_reent;                      
a000866c:	e58230f0 	str	r3, [r2, #240]	; 0xf0                         <== NOT EXECUTED
     _fwalk (t->libc_reent, sync_wrapper);                            
a0008670:	e59000f0 	ldr	r0, [r0, #240]	; 0xf0                         <== NOT EXECUTED
a0008674:	eb002ab0 	bl	a001313c <_fwalk>                              <== NOT EXECUTED
     _Thread_Executing->libc_reent = current_reent;                   
a0008678:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a000867c:	e58350f0 	str	r5, [r3, #240]	; 0xf0                         <== NOT EXECUTED
a0008680:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000868c <sync_wrapper>: /* XXX check standards -- Linux version appears to be void */ void _fwalk(struct _reent *, void *); static void sync_wrapper(FILE *f) {
a000868c:	e92d4010 	push	{r4, lr}                                     <== NOT EXECUTED
  int fn = fileno(f);                                                 
a0008690:	eb0027c5 	bl	a00125ac <fileno>                              <== NOT EXECUTED
a0008694:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  /*                                                                  
   *  We are explicitly NOT checking the return values as it does not 
   *  matter if they succeed.  We are just making a best faith attempt
   *  at both and trusting that we were passed a good FILE pointer.   
   */                                                                 
  fsync(fn);                                                          
a0008698:	ebfffad5 	bl	a00071f4 <fsync>                               <== NOT EXECUTED
  fdatasync(fn);                                                      
a000869c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
}                                                                     
a00086a0:	e8bd4010 	pop	{r4, lr}                                      <== NOT EXECUTED
   *  We are explicitly NOT checking the return values as it does not 
   *  matter if they succeed.  We are just making a best faith attempt
   *  at both and trusting that we were passed a good FILE pointer.   
   */                                                                 
  fsync(fn);                                                          
  fdatasync(fn);                                                      
a00086a4:	eafffa16 	b	a0006f04 <fdatasync>                            <== NOT EXECUTED
                                                                      

a000af30 <tcdrain>: int tcdrain( int fd ) { return ioctl( fd, RTEMS_IO_TCDRAIN, 0 );
a000af30:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a000af34:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000af38:	ea001dd1 	b	a0012684 <ioctl>                                <== NOT EXECUTED
                                                                      

a0007338 <tcflow>: int tcflow ( int fd __attribute__((unused)), int action ) {
a0007338:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
    case TCOOFF:                                                      
    case TCOON:                                                       
    case TCIOFF:                                                      
    case TCION:                                                       
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a000733c:	eb001fa1 	bl	a000f1c8 <__errno>                             <== NOT EXECUTED
a0007340:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a0007344:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
                                                                      
  /* fd is not validated */                                           
                                                                      
  /* When this is supported, implement it here */                     
  rtems_set_errno_and_return_minus_one( ENOTSUP );                    
}                                                                     
a0007348:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000734c:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a0007350 <tcflush>: int tcflush ( int fd __attribute__((unused)), int queue ) {
a0007350:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  switch (queue) {                                                    
    case TCIFLUSH:                                                    
    case TCOFLUSH:                                                    
    case TCIOFLUSH:                                                   
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a0007354:	eb001f9b 	bl	a000f1c8 <__errno>                             <== NOT EXECUTED
a0007358:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000735c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
  /* fd is not validated */                                           
                                                                      
  /* When this is supported, implement it here */                     
  rtems_set_errno_and_return_minus_one( ENOTSUP );                    
  return 0;                                                           
}                                                                     
a0007360:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a0007364:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)                    <== NOT EXECUTED
                                                                      

a000fb40 <tcgetattr>: int tcgetattr( int fd, struct termios *tp ) {
a000fb40:	e1a02001 	mov	r2, r1                                        <== NOT EXECUTED
  return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp );                    
a000fb44:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
a000fb48:	eaffff17 	b	a000f7ac <ioctl>                                <== NOT EXECUTED
                                                                      

a0007368 <tcgetpgrp>: #include <sys/types.h> #include <unistd.h> pid_t tcgetpgrp(int fd __attribute__((unused))) { return getpid();
a0007368:	eafffc67 	b	a000650c <getpid>                               <== NOT EXECUTED
                                                                      

a000736c <tcsendbreak>: int tcsendbreak ( int fd __attribute__((unused)), int duration __attribute__((unused)) ) { return 0; }
a000736c:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007370:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000fb4c <tcsetattr>: int fd, int opt, struct termios *tp ) { switch (opt) {
a000fb4c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
int tcsetattr(                                                        
  int             fd,                                                 
  int             opt,                                                
  struct termios *tp                                                  
)                                                                     
{                                                                     
a000fb50:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
a000fb54:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
a000fb58:	e1a04002 	mov	r4, r2                                        <== NOT EXECUTED
  switch (opt) {                                                      
a000fb5c:	0a00000b 	beq	a000fb90 <tcsetattr+0x44>                     <== NOT EXECUTED
a000fb60:	e3510001 	cmp	r1, #1                                        <== NOT EXECUTED
a000fb64:	0a000004 	beq	a000fb7c <tcsetattr+0x30>                     <== NOT EXECUTED
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
a000fb68:	eb000bec 	bl	a0012b20 <__errno>                             <== NOT EXECUTED
a000fb6c:	e3a03086 	mov	r3, #134	; 0x86                               <== NOT EXECUTED
a000fb70:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
  }                                                                   
}                                                                     
a000fb74:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000fb78:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  switch (opt) {                                                      
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
                                                                      
  case TCSADRAIN:                                                     
    if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)                      
a000fb7c:	e3a01003 	mov	r1, #3                                        <== NOT EXECUTED
a000fb80:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000fb84:	ebffff08 	bl	a000f7ac <ioctl>                               <== NOT EXECUTED
a000fb88:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000fb8c:	bafffff8 	blt	a000fb74 <tcsetattr+0x28>                     <== NOT EXECUTED
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
a000fb90:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000fb94:	e3a01002 	mov	r1, #2                                        <== NOT EXECUTED
a000fb98:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
  }                                                                   
}                                                                     
a000fb9c:	e8bd4030 	pop	{r4, r5, lr}                                  <== NOT EXECUTED
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
a000fba0:	eaffff01 	b	a000f7ac <ioctl>                                <== NOT EXECUTED
                                                                      

a0007374 <tcsetpgrp>: int tcsetpgrp( int fd __attribute__((unused)), pid_t pid __attribute__((unused)) ) { return 0; }
a0007374:	e3a00000 	mov	r0, #0                                        <== NOT EXECUTED
a0007378:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000938c <times>: clock_t times( struct tms *ptms ) { return _times( ptms );
a000938c:	eaffffcf 	b	a00092d0 <_times>                               <== NOT EXECUTED
                                                                      

a000cc94 <truncate>: int truncate( const char *path, off_t length ) {
a000cc94:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a000cc98:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_WRONLY );                                        
a000cc9c:	e3a01001 	mov	r1, #1                                        <== NOT EXECUTED
                                                                      
int truncate(                                                         
  const char  *path,                                                  
  off_t        length                                                 
)                                                                     
{                                                                     
a000cca0:	e1a06002 	mov	r6, r2                                        <== NOT EXECUTED
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_WRONLY );                                        
a000cca4:	ebfff6a6 	bl	a000a744 <open>                                <== NOT EXECUTED
  if ( fd == -1 )                                                     
a000cca8:	e3700001 	cmn	r0, #1                                        <== NOT EXECUTED
)                                                                     
{                                                                     
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_WRONLY );                                        
a000ccac:	e1a04000 	mov	r4, r0                                        <== NOT EXECUTED
  if ( fd == -1 )                                                     
    return -1;                                                        
a000ccb0:	01a05000 	moveq	r5, r0                                      <== NOT EXECUTED
{                                                                     
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_WRONLY );                                        
  if ( fd == -1 )                                                     
a000ccb4:	0a000005 	beq	a000ccd0 <truncate+0x3c>                      <== NOT EXECUTED
    return -1;                                                        
                                                                      
  status = ftruncate( fd, length );                                   
a000ccb8:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000ccbc:	e1a02006 	mov	r2, r6                                        <== NOT EXECUTED
a000ccc0:	eb001638 	bl	a00125a8 <ftruncate>                           <== NOT EXECUTED
a000ccc4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  (void) close( fd );                                                 
a000ccc8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000cccc:	ebfff140 	bl	a00091d4 <close>                               <== NOT EXECUTED
                                                                      
  return status;                                                      
}                                                                     
a000ccd0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000ccd4:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      

a000a42c <umask>: mode_t cmask ) { mode_t old_mask; old_mask = rtems_filesystem_umask;
a000a42c:	e59f3010 	ldr	r3, [pc, #16]	; a000a444 <umask+0x18>         <== NOT EXECUTED
a000a430:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000a434:	e593202c 	ldr	r2, [r3, #44]	; 0x2c                          <== NOT EXECUTED
  rtems_filesystem_umask = cmask;                                     
a000a438:	e583002c 	str	r0, [r3, #44]	; 0x2c                          <== NOT EXECUTED
                                                                      
  return old_mask;                                                    
}                                                                     
a000a43c:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
a000a440:	e12fff1e 	bx	lr                                             <== NOT EXECUTED
                                                                      

a000a0ec <unlink>: #include <rtems/seterr.h> int unlink( const char *path ) {
a000a0ec:	e92d40f0 	push	{r4, r5, r6, r7, lr}                         <== NOT EXECUTED
a000a0f0:	e24dd030 	sub	sp, sp, #48	; 0x30                            <== NOT EXECUTED
a000a0f4:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Get the node to be unlinked. Find the parent path first.         
   */                                                                 
                                                                      
  parentpathlen = rtems_filesystem_dirname ( path );                  
a000a0f8:	ebfff457 	bl	a000725c <rtems_filesystem_dirname>            <== NOT EXECUTED
                                                                      
  if ( parentpathlen == 0 )                                           
a000a0fc:	e2505000 	subs	r5, r0, #0                                   <== NOT EXECUTED
a000a100:	1a00003a 	bne	a000a1f0 <unlink+0x104>                       <== NOT EXECUTED
    rtems_filesystem_get_start_loc( path, &i, &parentloc );           
a000a104:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a000a108:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a10c:	e28d102c 	add	r1, sp, #44	; 0x2c                            <== NOT EXECUTED
a000a110:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000a114:	ebfff87a 	bl	a0008304 <rtems_filesystem_get_start_loc>      <== NOT EXECUTED
  const char                       *name;                             
  rtems_filesystem_location_info_t  parentloc;                        
  rtems_filesystem_location_info_t  loc;                              
  int                               i;                                
  int                               result;                           
  bool                              free_parentloc = false;           
a000a118:	e1a06005 	mov	r6, r5                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
a000a11c:	e28dc004 	add	ip, sp, #4                                    <== NOT EXECUTED
a000a120:	e1a0e004 	mov	lr, r4                                        <== NOT EXECUTED
a000a124:	e8be000f 	ldm	lr!, {r0, r1, r2, r3}                         <== NOT EXECUTED
a000a128:	e8ac000f 	stmia	ip!, {r0, r1, r2, r3}                       <== NOT EXECUTED
a000a12c:	e59e3000 	ldr	r3, [lr]                                      <== NOT EXECUTED
  name = path + parentpathlen;                                        
a000a130:	e0875005 	add	r5, r7, r5                                    <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000a134:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Start from the parent to find the node that should be under it.  
   */                                                                 
                                                                      
  loc = parentloc;                                                    
a000a138:	e58c3000 	str	r3, [ip]                                      <== NOT EXECUTED
  name = path + parentpathlen;                                        
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
a000a13c:	eb002fc1 	bl	a0016048 <strlen>                              <== NOT EXECUTED
a000a140:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a144:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a148:	ebfff452 	bl	a0007298 <rtems_filesystem_prefix_separators>  <== NOT EXECUTED
a000a14c:	e0857000 	add	r7, r5, r0                                    <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
a000a150:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a154:	eb002fbb 	bl	a0016048 <strlen>                              <== NOT EXECUTED
a000a158:	e28d5004 	add	r5, sp, #4                                    <== NOT EXECUTED
a000a15c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a160:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000a164:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a168:	e1a03005 	mov	r3, r5                                        <== NOT EXECUTED
a000a16c:	e58d2000 	str	r2, [sp]                                      <== NOT EXECUTED
a000a170:	ebfff407 	bl	a0007194 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
a000a174:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a178:	1a000014 	bne	a000a1d0 <unlink+0xe4>                        <== NOT EXECUTED
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    return -1;                                                        
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
a000a17c:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000a180:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a184:	e5933010 	ldr	r3, [r3, #16]                                 <== NOT EXECUTED
a000a188:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a18c:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000a190:	0a000022 	beq	a000a220 <unlink+0x134>                       <== NOT EXECUTED
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
    rtems_set_errno_and_return_minus_one( EISDIR );                   
  }                                                                   
                                                                      
  result = (*loc.ops->unlink_h)( &parentloc, &loc );                  
a000a194:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000a198:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000a19c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a1a0:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a000a1a4:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a1a8:	e1a07000 	mov	r7, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a000a1ac:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a1b0:	ebfff44d 	bl	a00072ec <rtems_filesystem_freenode>           <== NOT EXECUTED
  if ( free_parentloc )                                               
a000a1b4:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000a1b8:	0a000001 	beq	a000a1c4 <unlink+0xd8>                        <== NOT EXECUTED
    rtems_filesystem_freenode( &parentloc );                          
a000a1bc:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a1c0:	ebfff449 	bl	a00072ec <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a000a1c4:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a1c8:	e28dd030 	add	sp, sp, #48	; 0x30                            <== NOT EXECUTED
a000a1cc:	e8bd80f0 	pop	{r4, r5, r6, r7, pc}                          <== NOT EXECUTED
  name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
    if ( free_parentloc )                                             
a000a1d0:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000a1d4:	1a000001 	bne	a000a1e0 <unlink+0xf4>                        <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
    return -1;                                                        
a000a1d8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a000a1dc:	eafffff8 	b	a000a1c4 <unlink+0xd8>                          <== NOT EXECUTED
                                                                      
  result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
                                                    0, &loc, false ); 
  if ( result != 0 ) {                                                
    if ( free_parentloc )                                             
      rtems_filesystem_freenode( &parentloc );                        
a000a1e0:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a1e4:	ebfff440 	bl	a00072ec <rtems_filesystem_freenode>           <== NOT EXECUTED
    return -1;                                                        
a000a1e8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a000a1ec:	eafffff4 	b	a000a1c4 <unlink+0xd8>                          <== NOT EXECUTED
  parentpathlen = rtems_filesystem_dirname ( path );                  
                                                                      
  if ( parentpathlen == 0 )                                           
    rtems_filesystem_get_start_loc( path, &i, &parentloc );           
  else {                                                              
    result = rtems_filesystem_evaluate_path( path, parentpathlen,     
a000a1f0:	e3a03000 	mov	r3, #0                                        <== NOT EXECUTED
a000a1f4:	e28d4018 	add	r4, sp, #24                                   <== NOT EXECUTED
a000a1f8:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000a1fc:	e3a02002 	mov	r2, #2                                        <== NOT EXECUTED
a000a200:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a204:	e1a01005 	mov	r1, r5                                        <== NOT EXECUTED
a000a208:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000a20c:	ebfff3fc 	bl	a0007204 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
                                             RTEMS_LIBIO_PERMS_WRITE, 
                                             &parentloc,              
                                             false );                 
    if ( result != 0 )                                                
a000a210:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a214:	1affffef 	bne	a000a1d8 <unlink+0xec>                        <== NOT EXECUTED
      return -1;                                                      
                                                                      
    free_parentloc = true;                                            
a000a218:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
a000a21c:	eaffffbe 	b	a000a11c <unlink+0x30>                          <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
    return -1;                                                        
  }                                                                   
                                                                      
  if (  (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
    rtems_filesystem_freenode( &loc );                                
a000a220:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a224:	ebfff430 	bl	a00072ec <rtems_filesystem_freenode>           <== NOT EXECUTED
    if ( free_parentloc )                                             
a000a228:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000a22c:	0a000001 	beq	a000a238 <unlink+0x14c>                       <== NOT EXECUTED
      rtems_filesystem_freenode( &parentloc );                        
a000a230:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a234:	ebfff42c 	bl	a00072ec <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EISDIR );                   
a000a238:	eb002bc3 	bl	a001514c <__errno>                             <== NOT EXECUTED
a000a23c:	e3a03015 	mov	r3, #21                                       <== NOT EXECUTED
a000a240:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000a244:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a000a248:	eaffffdd 	b	a000a1c4 <unlink+0xd8>                          <== NOT EXECUTED
                                                                      

a000a288 <unmount>: */ int unmount( const char *path ) {
a000a288:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a000a28c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a000a290:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
   *    The root node of the mounted filesytem.                       
   *    The node for the directory that the fileystem is mounted on.  
   *    The mount entry that is being refered to.                     
   */                                                                 
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
a000a294:	eb002468 	bl	a001343c <strlen>                              <== NOT EXECUTED
a000a298:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a000a29c:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a2a0:	e3a0c001 	mov	ip, #1                                        <== NOT EXECUTED
a000a2a4:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a2a8:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000a2ac:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000a2b0:	e58dc000 	str	ip, [sp]                                      <== NOT EXECUTED
a000a2b4:	ebfff334 	bl	a0006f8c <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a000a2b8:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a2bc:	1a00001a 	bne	a000a32c <unmount+0xa4>                       <== NOT EXECUTED
    return -1;                                                        
                                                                      
  mt_entry     = loc.mt_entry;                                        
a000a2c0:	e59d5014 	ldr	r5, [sp, #20]                                 <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Verify this is the root node for the file system to be unmounted.
   */                                                                 
                                                                      
  if ( fs_root_loc->node_access != loc.node_access ){                 
a000a2c4:	e59d3004 	ldr	r3, [sp, #4]                                  <== NOT EXECUTED
a000a2c8:	e595201c 	ldr	r2, [r5, #28]                                 <== NOT EXECUTED
a000a2cc:	e1520003 	cmp	r2, r3                                        <== NOT EXECUTED
a000a2d0:	1a00002d 	bne	a000a38c <unmount+0x104>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Free the loc node and just use the nodes from the mt_entry .     
   */                                                                 
                                                                      
  rtems_filesystem_freenode( &loc );                                  
a000a2d4:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a2d8:	ebfff365 	bl	a0007074 <rtems_filesystem_freenode>           <== NOT EXECUTED
   *        that made the current node thread based instead           
   *        of system based?  I thought it was but it doesn't         
   *        look like it in this version.                             
   */                                                                 
                                                                      
  if ( rtems_filesystem_current.mt_entry == mt_entry )                
a000a2dc:	e59f30f8 	ldr	r3, [pc, #248]	; a000a3dc <unmount+0x154>     <== NOT EXECUTED
a000a2e0:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000a2e4:	e5933014 	ldr	r3, [r3, #20]                                 <== NOT EXECUTED
a000a2e8:	e1530005 	cmp	r3, r5                                        <== NOT EXECUTED
a000a2ec:	0a00002d 	beq	a000a3a8 <unmount+0x120>                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Verify there are no file systems below the path specified       
   */                                                                 
                                                                      
  if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,       
a000a2f0:	e59f00e8 	ldr	r0, [pc, #232]	; a000a3e0 <unmount+0x158>     <== NOT EXECUTED
a000a2f4:	e595102c 	ldr	r1, [r5, #44]	; 0x2c                          <== NOT EXECUTED
a000a2f8:	ebfff5cc 	bl	a0007a30 <rtems_filesystem_mount_iterate>      <== NOT EXECUTED
a000a2fc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a300:	1a000028 	bne	a000a3a8 <unmount+0x120>                      <== NOT EXECUTED
   *  Run the file descriptor table to determine if there are any file
   *  descriptors that are currently active and reference nodes in the
   *  file system that we are trying to unmount                       
   */                                                                 
                                                                      
  if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )             
a000a304:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a308:	ebfff461 	bl	a0007494 <rtems_libio_is_open_files_in_fs>     <== NOT EXECUTED
a000a30c:	e3500001 	cmp	r0, #1                                        <== NOT EXECUTED
a000a310:	0a000024 	beq	a000a3a8 <unmount+0x120>                      <== NOT EXECUTED
   * Allow the file system being unmounted on to do its cleanup.      
   * If it fails it will set the errno to the approprate value        
   * and the fileystem will not be modified.                          
   */                                                                 
                                                                      
  if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )             
a000a314:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a000a318:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a31c:	e5933028 	ldr	r3, [r3, #40]	; 0x28                          <== NOT EXECUTED
a000a320:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a324:	e2506000 	subs	r6, r0, #0                                   <== NOT EXECUTED
a000a328:	0a000002 	beq	a000a338 <unmount+0xb0>                       <== NOT EXECUTED
   */                                                                 
                                                                      
  if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){          
    if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )             
      rtems_fatal_error_occurred( 0 );                                
    return -1;                                                        
a000a32c:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( fs_mount_loc );                          
  free( mt_entry );                                                   
                                                                      
  return 0;                                                           
}                                                                     
a000a330:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a000a334:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
   *  NOTE:  Fatal error is called in a case which should never happen
   *         This was response was questionable but the best we could 
   *         come up with.                                            
   */                                                                 
                                                                      
  if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){          
a000a338:	e5953028 	ldr	r3, [r5, #40]	; 0x28                          <== NOT EXECUTED
a000a33c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a340:	e593302c 	ldr	r3, [r3, #44]	; 0x2c                          <== NOT EXECUTED
a000a344:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a348:	e2504000 	subs	r4, r0, #0                                   <== NOT EXECUTED
a000a34c:	1a00001a 	bne	a000a3bc <unmount+0x134>                      <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);                  
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;   
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
a000a350:	e59f608c 	ldr	r6, [pc, #140]	; a000a3e4 <unmount+0x15c>     <== NOT EXECUTED
a000a354:	e1a01004 	mov	r1, r4                                        <== NOT EXECUTED
a000a358:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000a35c:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000a360:	eb000295 	bl	a000adbc <rtems_semaphore_obtain>              <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
a000a364:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a368:	eb0004e7 	bl	a000b70c <_Chain_Extract>                      <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
a000a36c:	e5960000 	ldr	r0, [r6]                                      <== NOT EXECUTED
a000a370:	eb0002da 	bl	a000aee0 <rtems_semaphore_release>             <== NOT EXECUTED
  /*                                                                  
   *  Free the memory node that was allocated in mount                
   *  Free the memory associated with the extracted mount table entry.
   */                                                                 
                                                                      
  rtems_filesystem_freenode( fs_mount_loc );                          
a000a374:	e2850008 	add	r0, r5, #8                                    <== NOT EXECUTED
a000a378:	ebfff33d 	bl	a0007074 <rtems_filesystem_freenode>           <== NOT EXECUTED
  free( mt_entry );                                                   
a000a37c:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a380:	ebfff340 	bl	a0007088 <free>                                <== NOT EXECUTED
                                                                      
  return 0;                                                           
a000a384:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a388:	eaffffe8 	b	a000a330 <unmount+0xa8>                         <== NOT EXECUTED
  /*                                                                  
   * Verify this is the root node for the file system to be unmounted.
   */                                                                 
                                                                      
  if ( fs_root_loc->node_access != loc.node_access ){                 
    rtems_filesystem_freenode( &loc );                                
a000a38c:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a390:	ebfff337 	bl	a0007074 <rtems_filesystem_freenode>           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EACCES );                   
a000a394:	eb001eb0 	bl	a0011e5c <__errno>                             <== NOT EXECUTED
a000a398:	e3a0300d 	mov	r3, #13                                       <== NOT EXECUTED
a000a39c:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000a3a0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000a3a4:	eaffffe1 	b	a000a330 <unmount+0xa8>                         <== NOT EXECUTED
   *  descriptors that are currently active and reference nodes in the
   *  file system that we are trying to unmount                       
   */                                                                 
                                                                      
  if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )             
    rtems_set_errno_and_return_minus_one( EBUSY );                    
a000a3a8:	eb001eab 	bl	a0011e5c <__errno>                             <== NOT EXECUTED
a000a3ac:	e3a03010 	mov	r3, #16                                       <== NOT EXECUTED
a000a3b0:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000a3b4:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a000a3b8:	eaffffdc 	b	a000a330 <unmount+0xa8>                         <== NOT EXECUTED
   *         This was response was questionable but the best we could 
   *         come up with.                                            
   */                                                                 
                                                                      
  if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){          
    if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )             
a000a3bc:	e5953014 	ldr	r3, [r5, #20]                                 <== NOT EXECUTED
a000a3c0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a3c4:	e5933020 	ldr	r3, [r3, #32]                                 <== NOT EXECUTED
a000a3c8:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a3cc:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a3d0:	0affffd5 	beq	a000a32c <unmount+0xa4>                       <== NOT EXECUTED
      rtems_fatal_error_occurred( 0 );                                
a000a3d4:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a3d8:	eb000407 	bl	a000b3fc <rtems_fatal_error_occurred>          <== NOT EXECUTED
                                                                      

a000a448 <utime>: int utime( const char *path, const struct utimbuf *times ) {
a000a448:	e92d4070 	push	{r4, r5, r6, lr}                             <== NOT EXECUTED
a000a44c:	e24dd018 	sub	sp, sp, #24                                   <== NOT EXECUTED
a000a450:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
a000a454:	e1a06000 	mov	r6, r0                                        <== NOT EXECUTED
  rtems_filesystem_location_info_t   temp_loc;                        
  int                                result;                          
  struct utimbuf                     now;                             
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
a000a458:	eb002663 	bl	a0013dec <strlen>                              <== NOT EXECUTED
a000a45c:	e28d4004 	add	r4, sp, #4                                    <== NOT EXECUTED
a000a460:	e3a03001 	mov	r3, #1                                        <== NOT EXECUTED
a000a464:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a468:	e58d3000 	str	r3, [sp]                                      <== NOT EXECUTED
a000a46c:	e3a02000 	mov	r2, #0                                        <== NOT EXECUTED
a000a470:	e1a00006 	mov	r0, r6                                        <== NOT EXECUTED
a000a474:	e1a03004 	mov	r3, r4                                        <== NOT EXECUTED
a000a478:	ebfff1e8 	bl	a0006c20 <rtems_filesystem_evaluate_path>      <== NOT EXECUTED
a000a47c:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
    return -1;                                                        
a000a480:	13e05000 	mvnne	r5, #0                                      <== NOT EXECUTED
{                                                                     
  rtems_filesystem_location_info_t   temp_loc;                        
  int                                result;                          
  struct utimbuf                     now;                             
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
a000a484:	1a000009 	bne	a000a4b0 <utime+0x68>                         <== NOT EXECUTED
    return -1;                                                        
                                                                      
  if ( times == NULL ) {                                              
a000a488:	e3550000 	cmp	r5, #0                                        <== NOT EXECUTED
a000a48c:	0a00000a 	beq	a000a4bc <utime+0x74>                         <== NOT EXECUTED
a000a490:	e8950006 	ldm	r5, {r1, r2}                                  <== NOT EXECUTED
    now.actime = now.modtime = time( NULL );                          
    times = &now;                                                     
  }                                                                   
                                                                      
  result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
a000a494:	e59d3010 	ldr	r3, [sp, #16]                                 <== NOT EXECUTED
a000a498:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a49c:	e5933030 	ldr	r3, [r3, #48]	; 0x30                          <== NOT EXECUTED
a000a4a0:	e12fff33 	blx	r3                                            <== NOT EXECUTED
a000a4a4:	e1a05000 	mov	r5, r0                                        <== NOT EXECUTED
                                                                      
  rtems_filesystem_freenode( &temp_loc );                             
a000a4a8:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a000a4ac:	ebfff2f9 	bl	a0007098 <rtems_filesystem_freenode>           <== NOT EXECUTED
                                                                      
  return result;                                                      
}                                                                     
a000a4b0:	e1a00005 	mov	r0, r5                                        <== NOT EXECUTED
a000a4b4:	e28dd018 	add	sp, sp, #24                                   <== NOT EXECUTED
a000a4b8:	e8bd8070 	pop	{r4, r5, r6, pc}                              <== NOT EXECUTED
                                                                      
  if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
    return -1;                                                        
                                                                      
  if ( times == NULL ) {                                              
    now.actime = now.modtime = time( NULL );                          
a000a4bc:	eb00269d 	bl	a0013f38 <time>                                <== NOT EXECUTED
a000a4c0:	e1a02000 	mov	r2, r0                                        <== NOT EXECUTED
a000a4c4:	e1a01000 	mov	r1, r0                                        <== NOT EXECUTED
a000a4c8:	eafffff1 	b	a000a494 <utime+0x4c>                           <== NOT EXECUTED
                                                                      

a000a4cc <utimes>: int utimes( const char *path, const struct timeval times[2] ) {
a000a4cc:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)                 <== NOT EXECUTED
  struct utimbuf timeinsecs;                                          
                                                                      
  if ( times == NULL )                                                
a000a4d0:	e2513000 	subs	r3, r1, #0                                   <== NOT EXECUTED
    return utime( path, NULL );                                       
                                                                      
  timeinsecs.actime  = (time_t) times[0].tv_sec;                      
a000a4d4:	15932000 	ldrne	r2, [r3]                                    <== NOT EXECUTED
  timeinsecs.modtime = (time_t) times[1].tv_sec;                      
a000a4d8:	15933008 	ldrne	r3, [r3, #8]                                <== NOT EXECUTED
                                                                      
int utimes(                                                           
  const char           *path,                                         
  const struct timeval  times[2]                                      
)                                                                     
{                                                                     
a000a4dc:	e24dd008 	sub	sp, sp, #8                                    <== NOT EXECUTED
    return utime( path, NULL );                                       
                                                                      
  timeinsecs.actime  = (time_t) times[0].tv_sec;                      
  timeinsecs.modtime = (time_t) times[1].tv_sec;                      
                                                                      
  return utime( path, &timeinsecs );                                  
a000a4e0:	11a0100d 	movne	r1, sp                                      <== NOT EXECUTED
  struct utimbuf timeinsecs;                                          
                                                                      
  if ( times == NULL )                                                
    return utime( path, NULL );                                       
                                                                      
  timeinsecs.actime  = (time_t) times[0].tv_sec;                      
a000a4e4:	158d2000 	strne	r2, [sp]                                    <== NOT EXECUTED
  timeinsecs.modtime = (time_t) times[1].tv_sec;                      
a000a4e8:	158d3004 	strne	r3, [sp, #4]                                <== NOT EXECUTED
                                                                      
  return utime( path, &timeinsecs );                                  
a000a4ec:	ebffffd5 	bl	a000a448 <utime>                               <== NOT EXECUTED
}                                                                     
a000a4f0:	e28dd008 	add	sp, sp, #8                                    <== NOT EXECUTED
a000a4f4:	e8bd8000 	pop	{pc}                                          <== NOT EXECUTED
                                                                      

a0009028 <vprintk>: */ void vprintk( const char *fmt, va_list ap ) {
a0009028:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}         
a000902c:	e1a0a000 	mov	sl, r0                                        
  for (; *fmt != '\0'; fmt++) {                                       
a0009030:	e5d00000 	ldrb	r0, [r0]                                     
 */                                                                   
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
a0009034:	e24dd01c 	sub	sp, sp, #28                                   
a0009038:	e58d1004 	str	r1, [sp, #4]                                  
  for (; *fmt != '\0'; fmt++) {                                       
a000903c:	e3500000 	cmp	r0, #0                                        
a0009040:	0a000073 	beq	a0009214 <vprintk+0x1ec>                      
    bool sign = false;                                                
    char lead = ' ';                                                  
    char c;                                                           
                                                                      
    if (*fmt != '%') {                                                
      BSP_output_char(*fmt);                                          
a0009044:	e59f8374 	ldr	r8, [pc, #884]	; a00093c0 <vprintk+0x398>     
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
a0009048:	e28db008 	add	fp, sp, #8                                    
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
    char c;                                                           
                                                                      
    if (*fmt != '%') {                                                
a000904c:	e3500025 	cmp	r0, #37	; 0x25                                
a0009050:	1a000071 	bne	a000921c <vprintk+0x1f4>                      
      BSP_output_char(*fmt);                                          
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
a0009054:	e5fa3001 	ldrb	r3, [sl, #1]!                                
a0009058:	e3530030 	cmp	r3, #48	; 0x30                                
      lead = '0';                                                     
      fmt++;                                                          
a000905c:	05fa3001 	ldrbeq	r3, [sl, #1]!                              
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
a0009060:	13a02020 	movne	r2, #32                                     
      BSP_output_char(*fmt);                                          
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
a0009064:	03a01030 	moveq	r1, #48	; 0x30                              
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
a0009068:	158d2000 	strne	r2, [sp]                                    
      BSP_output_char(*fmt);                                          
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
a000906c:	058d1000 	streq	r1, [sp]                                    
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
a0009070:	e353002d 	cmp	r3, #45	; 0x2d                                
      minus = true;                                                   
      fmt++;                                                          
a0009074:	05fa3001 	ldrbeq	r3, [sl, #1]!                              
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
a0009078:	03a07001 	moveq	r7, #1                                      
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
    bool minus = false;                                               
a000907c:	13a07000 	movne	r7, #0                                      
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
a0009080:	e2432030 	sub	r2, r3, #48	; 0x30                            
a0009084:	e3520009 	cmp	r2, #9                                        
a0009088:	83a06000 	movhi	r6, #0                                      
a000908c:	8a000009 	bhi	a00090b8 <vprintk+0x90>                       
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
a0009090:	e28a2001 	add	r2, sl, #1                                    
a0009094:	e3a06000 	mov	r6, #0                                        
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
a0009098:	e3a0100a 	mov	r1, #10                                       
a000909c:	e0263691 	mla	r6, r1, r6, r3                                
a00090a0:	e1a0a002 	mov	sl, r2                                        
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
a00090a4:	e4d23001 	ldrb	r3, [r2], #1                                 
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
a00090a8:	e2466030 	sub	r6, r6, #48	; 0x30                            
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
a00090ac:	e2431030 	sub	r1, r3, #48	; 0x30                            
a00090b0:	e3510009 	cmp	r1, #9                                        
a00090b4:	9afffff7 	bls	a0009098 <vprintk+0x70>                       
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
a00090b8:	e353006c 	cmp	r3, #108	; 0x6c                               
      lflag = true;                                                   
      c = *++fmt;                                                     
a00090bc:	05fa0001 	ldrbeq	r0, [sl, #1]!                              
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
a00090c0:	11a00003 	movne	r0, r3                                      
      lflag = true;                                                   
a00090c4:	03a03001 	moveq	r3, #1                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
a00090c8:	13a03000 	movne	r3, #0                                      
                                                                      
    if ((c = *fmt) == 'l') {                                          
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
a00090cc:	e3500063 	cmp	r0, #99	; 0x63                                
a00090d0:	0a000098 	beq	a0009338 <vprintk+0x310>                      
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
      BSP_output_char(chr);                                           
      continue;                                                       
    }                                                                 
    if ( c == 's' ) {                                                 
a00090d4:	e3500073 	cmp	r0, #115	; 0x73                               
a00090d8:	0a00005a 	beq	a0009248 <vprintk+0x220>                      
                                                                      
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
a00090dc:	e350006f 	cmp	r0, #111	; 0x6f                               
a00090e0:	1350004f 	cmpne	r0, #79	; 0x4f                              
      base = 8; sign = false;                                         
a00090e4:	03a02000 	moveq	r2, #0                                      
a00090e8:	03a09008 	moveq	r9, #8                                      
                                                                      
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
a00090ec:	0a000009 	beq	a0009118 <vprintk+0xf0>                       
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
a00090f0:	e3500069 	cmp	r0, #105	; 0x69                               
a00090f4:	13500049 	cmpne	r0, #73	; 0x49                              
a00090f8:	0a000004 	beq	a0009110 <vprintk+0xe8>                       
                c == 'd' || c == 'D' ) {                              
a00090fc:	e3500064 	cmp	r0, #100	; 0x64                               
a0009100:	13500044 	cmpne	r0, #68	; 0x44                              
a0009104:	13a02000 	movne	r2, #0                                      
a0009108:	03a02001 	moveq	r2, #1                                      
a000910c:	1a000093 	bne	a0009360 <vprintk+0x338>                      
      base = 10; sign = true;                                         
a0009110:	e3a02001 	mov	r2, #1                                        
a0009114:	e3a0900a 	mov	r9, #10                                       
    } else {                                                          
      BSP_output_char(c);                                             
      continue;                                                       
    }                                                                 
                                                                      
    printNum(                                                         
a0009118:	e3530000 	cmp	r3, #0                                        
a000911c:	0a000044 	beq	a0009234 <vprintk+0x20c>                      
a0009120:	e59d1004 	ldr	r1, [sp, #4]                                  
a0009124:	e5917000 	ldr	r7, [r1]                                      
      lflag ? va_arg(ap, long) : (long) va_arg(ap, int),              
a0009128:	e2811004 	add	r1, r1, #4                                    
a000912c:	e58d1004 	str	r1, [sp, #4]                                  
  unsigned long unsigned_num;                                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
a0009130:	e3520000 	cmp	r2, #0                                        
a0009134:	0a000001 	beq	a0009140 <vprintk+0x118>                      
a0009138:	e3570000 	cmp	r7, #0                                        
a000913c:	ba000098 	blt	a00093a4 <vprintk+0x37c>                      
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
a0009140:	e1a00007 	mov	r0, r7                                        
a0009144:	e1a01009 	mov	r1, r9                                        
a0009148:	eb002da7 	bl	a00147ec <__aeabi_uidiv>                       
a000914c:	e3500000 	cmp	r0, #0                                        
a0009150:	e1a04000 	mov	r4, r0                                        
a0009154:	e1a05000 	mov	r5, r0                                        
a0009158:	01a04007 	moveq	r4, r7                                      
a000915c:	03a07001 	moveq	r7, #1                                      
a0009160:	0a000010 	beq	a00091a8 <vprintk+0x180>                      
a0009164:	e20930ff 	and	r3, r9, #255	; 0xff                           
a0009168:	e1a02007 	mov	r2, r7                                        
    if (maxwidth) maxwidth--;                                         
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
a000916c:	e3a05000 	mov	r5, #0                                        
a0009170:	e1a07003 	mov	r7, r3                                        
a0009174:	ea000001 	b	a0009180 <vprintk+0x158>                        
  while ((n = unsigned_num / base) > 0) {                             
a0009178:	e1a02004 	mov	r2, r4                                        
a000917c:	e1a04000 	mov	r4, r0                                        
    toPrint[count++] = (char) (unsigned_num - (n * base));            
a0009180:	e0030794 	mul	r3, r4, r7                                    
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
a0009184:	e1a00004 	mov	r0, r4                                        
    toPrint[count++] = (char) (unsigned_num - (n * base));            
a0009188:	e0633002 	rsb	r3, r3, r2                                    
a000918c:	e7cb3005 	strb	r3, [fp, r5]                                 
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
a0009190:	e1a01009 	mov	r1, r9                                        
a0009194:	eb002d94 	bl	a00147ec <__aeabi_uidiv>                       
a0009198:	e3500000 	cmp	r0, #0                                        
    toPrint[count++] = (char) (unsigned_num - (n * base));            
a000919c:	e2855001 	add	r5, r5, #1                                    
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
a00091a0:	1afffff4 	bne	a0009178 <vprintk+0x150>                      
a00091a4:	e2857001 	add	r7, r5, #1                                    
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
a00091a8:	e28d101c 	add	r1, sp, #28                                   
a00091ac:	e0815005 	add	r5, r1, r5                                    
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
a00091b0:	e1570006 	cmp	r7, r6                                        
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
a00091b4:	e5454014 	strb	r4, [r5, #-20]                               
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
a00091b8:	2a000006 	bcs	a00091d8 <vprintk+0x1b0>                      
a00091bc:	e59d4000 	ldr	r4, [sp]                                      
    BSP_output_char(lead);                                            
a00091c0:	e5983000 	ldr	r3, [r8]                                      
a00091c4:	e1a00004 	mov	r0, r4                                        
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
a00091c8:	e2466001 	sub	r6, r6, #1                                    
    BSP_output_char(lead);                                            
a00091cc:	e12fff33 	blx	r3                                            
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
a00091d0:	e1570006 	cmp	r7, r6                                        
a00091d4:	3afffff9 	bcc	a00091c0 <vprintk+0x198>                      
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
a00091d8:	e3570000 	cmp	r7, #0                                        
a00091dc:	0a000009 	beq	a0009208 <vprintk+0x1e0>                      
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
a00091e0:	e08b5007 	add	r5, fp, r7                                    
a00091e4:	e3a04000 	mov	r4, #0                                        
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
    BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 
a00091e8:	e5752001 	ldrb	r2, [r5, #-1]!                               
a00091ec:	e59f11d0 	ldr	r1, [pc, #464]	; a00093c4 <vprintk+0x39c>     
a00091f0:	e5983000 	ldr	r3, [r8]                                      
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
a00091f4:	e2844001 	add	r4, r4, #1                                    
    BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 
a00091f8:	e7d10002 	ldrb	r0, [r1, r2]                                 
a00091fc:	e12fff33 	blx	r3                                            
  toPrint[count++] = (char) unsigned_num;                             
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
    BSP_output_char(lead);                                            
                                                                      
  for (n = 0; n < count; n++) {                                       
a0009200:	e1570004 	cmp	r7, r4                                        
a0009204:	8afffff7 	bhi	a00091e8 <vprintk+0x1c0>                      
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
a0009208:	e5fa0001 	ldrb	r0, [sl, #1]!                                
a000920c:	e3500000 	cmp	r0, #0                                        
a0009210:	1affff8d 	bne	a000904c <vprintk+0x24>                       
      sign,                                                           
      width,                                                          
      lead                                                            
    );                                                                
  }                                                                   
}                                                                     
a0009214:	e28dd01c 	add	sp, sp, #28                                   
a0009218:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, sl, fp, pc}          
    } else if ( c == 'x' || c == 'X' ) {                              
      base = 16; sign = false;                                        
    } else if ( c == 'p' ) {                                          
      base = 16; sign = false; lflag = true;                          
    } else {                                                          
      BSP_output_char(c);                                             
a000921c:	e5983000 	ldr	r3, [r8]                                      
a0009220:	e12fff33 	blx	r3                                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
a0009224:	e5fa0001 	ldrb	r0, [sl, #1]!                                
a0009228:	e3500000 	cmp	r0, #0                                        
a000922c:	1affff86 	bne	a000904c <vprintk+0x24>                       
a0009230:	eafffff7 	b	a0009214 <vprintk+0x1ec>                        
    } else {                                                          
      BSP_output_char(c);                                             
      continue;                                                       
    }                                                                 
                                                                      
    printNum(                                                         
a0009234:	e59d3004 	ldr	r3, [sp, #4]                                  
a0009238:	e5937000 	ldr	r7, [r3]                                      
      lflag ? va_arg(ap, long) : (long) va_arg(ap, int),              
a000923c:	e2833004 	add	r3, r3, #4                                    
a0009240:	e58d3004 	str	r3, [sp, #4]                                  
a0009244:	eaffffb9 	b	a0009130 <vprintk+0x108>                        
    }                                                                 
    if ( c == 's' ) {                                                 
      unsigned i, len;                                                
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
a0009248:	e59d3004 	ldr	r3, [sp, #4]                                  
                                                                      
      if ( str == NULL ) {                                            
        str = "";                                                     
a000924c:	e59f2174 	ldr	r2, [pc, #372]	; a00093c8 <vprintk+0x3a0>     
    }                                                                 
    if ( c == 's' ) {                                                 
      unsigned i, len;                                                
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
a0009250:	e59d1004 	ldr	r1, [sp, #4]                                  
a0009254:	e5933000 	ldr	r3, [r3]                                      
a0009258:	e2819004 	add	r9, r1, #4                                    
                                                                      
      if ( str == NULL ) {                                            
        str = "";                                                     
a000925c:	e3530000 	cmp	r3, #0                                        
a0009260:	01a03002 	moveq	r3, r2                                      
a0009264:	e58d3000 	str	r3, [sp]                                      
      }                                                               
                                                                      
      /* calculate length of string */                                
      for ( len=0, s=str ; *s ; len++, s++ )                          
a0009268:	e5d34000 	ldrb	r4, [r3]                                     
a000926c:	e3540000 	cmp	r4, #0                                        
a0009270:	0a000004 	beq	a0009288 <vprintk+0x260>                      
a0009274:	e3a04000 	mov	r4, #0                                        
a0009278:	e5f32001 	ldrb	r2, [r3, #1]!                                
a000927c:	e2844001 	add	r4, r4, #1                                    
a0009280:	e3520000 	cmp	r2, #0                                        
a0009284:	1afffffb 	bne	a0009278 <vprintk+0x250>                      
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
a0009288:	e3570000 	cmp	r7, #0                                        
a000928c:	1a000008 	bne	a00092b4 <vprintk+0x28c>                      
        for ( i=len ; i<width ; i++ )                                 
a0009290:	e1540006 	cmp	r4, r6                                        
a0009294:	2a000006 	bcs	a00092b4 <vprintk+0x28c>                      
a0009298:	e1a05004 	mov	r5, r4                                        
          BSP_output_char(' ');                                       
a000929c:	e5983000 	ldr	r3, [r8]                                      
a00092a0:	e3a00020 	mov	r0, #32                                       
      for ( len=0, s=str ; *s ; len++, s++ )                          
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
        for ( i=len ; i<width ; i++ )                                 
a00092a4:	e2855001 	add	r5, r5, #1                                    
          BSP_output_char(' ');                                       
a00092a8:	e12fff33 	blx	r3                                            
      for ( len=0, s=str ; *s ; len++, s++ )                          
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
        for ( i=len ; i<width ; i++ )                                 
a00092ac:	e1550006 	cmp	r5, r6                                        
a00092b0:	3afffff9 	bcc	a000929c <vprintk+0x274>                      
          BSP_output_char(' ');                                       
                                                                      
      /* no width option */                                           
      if (width == 0) {                                               
a00092b4:	e3560000 	cmp	r6, #0                                        
a00092b8:	1a000002 	bne	a00092c8 <vprintk+0x2a0>                      
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
a00092bc:	e3540000 	cmp	r4, #0                                        
a00092c0:	0a00000d 	beq	a00092fc <vprintk+0x2d4>                      
a00092c4:	e1a06004 	mov	r6, r4                                        
a00092c8:	e59d3000 	ldr	r3, [sp]                                      
a00092cc:	e5d30000 	ldrb	r0, [r3]                                     
a00092d0:	e3500000 	cmp	r0, #0                                        
a00092d4:	0a000008 	beq	a00092fc <vprintk+0x2d4>                      
        BSP_output_char(*str);                                        
a00092d8:	e5983000 	ldr	r3, [r8]                                      
a00092dc:	e12fff33 	blx	r3                                            
a00092e0:	e59d5000 	ldr	r5, [sp]                                      
a00092e4:	ea000001 	b	a00092f0 <vprintk+0x2c8>                        
a00092e8:	e5983000 	ldr	r3, [r8]                                      
a00092ec:	e12fff33 	blx	r3                                            
      if (width == 0) {                                               
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
a00092f0:	e5f50001 	ldrb	r0, [r5, #1]!                                
a00092f4:	e3500000 	cmp	r0, #0                                        
a00092f8:	1afffffa 	bne	a00092e8 <vprintk+0x2c0>                      
        BSP_output_char(*str);                                        
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
a00092fc:	e3570000 	cmp	r7, #0                                        
a0009300:	0a000007 	beq	a0009324 <vprintk+0x2fc>                      
        for ( i=len ; i<width ; i++ )                                 
a0009304:	e1540006 	cmp	r4, r6                                        
a0009308:	2a000005 	bcs	a0009324 <vprintk+0x2fc>                      
          BSP_output_char(' ');                                       
a000930c:	e5983000 	ldr	r3, [r8]                                      
a0009310:	e3a00020 	mov	r0, #32                                       
      for ( i=0 ; i<width && *str ; str++ )                           
        BSP_output_char(*str);                                        
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
        for ( i=len ; i<width ; i++ )                                 
a0009314:	e2844001 	add	r4, r4, #1                                    
          BSP_output_char(' ');                                       
a0009318:	e12fff33 	blx	r3                                            
      for ( i=0 ; i<width && *str ; str++ )                           
        BSP_output_char(*str);                                        
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
        for ( i=len ; i<width ; i++ )                                 
a000931c:	e1540006 	cmp	r4, r6                                        
a0009320:	3afffff9 	bcc	a000930c <vprintk+0x2e4>                      
    }                                                                 
    if ( c == 's' ) {                                                 
      unsigned i, len;                                                
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
a0009324:	e58d9004 	str	r9, [sp, #4]                                  
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
a0009328:	e5fa0001 	ldrb	r0, [sl, #1]!                                
a000932c:	e3500000 	cmp	r0, #0                                        
a0009330:	1affff45 	bne	a000904c <vprintk+0x24>                       
a0009334:	eaffffb6 	b	a0009214 <vprintk+0x1ec>                        <== NOT EXECUTED
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
a0009338:	e59d2004 	ldr	r2, [sp, #4]                                  
      BSP_output_char(chr);                                           
a000933c:	e5983000 	ldr	r3, [r8]                                      
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
a0009340:	e2824004 	add	r4, r2, #4                                    
      BSP_output_char(chr);                                           
a0009344:	e5d20000 	ldrb	r0, [r2]                                     
a0009348:	e12fff33 	blx	r3                                            
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
      /* need a cast here since va_arg() only takes fully promoted types */
      char chr = (char) va_arg(ap, int);                              
a000934c:	e58d4004 	str	r4, [sp, #4]                                  
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
a0009350:	e5fa0001 	ldrb	r0, [sl, #1]!                                
a0009354:	e3500000 	cmp	r0, #0                                        
a0009358:	1affff3b 	bne	a000904c <vprintk+0x24>                       
a000935c:	eaffffac 	b	a0009214 <vprintk+0x1ec>                        <== NOT EXECUTED
    if ( c == 'o' || c == 'O' ) {                                     
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
                c == 'd' || c == 'D' ) {                              
      base = 10; sign = true;                                         
    } else if ( c == 'u' || c == 'U' ) {                              
a0009360:	e3500075 	cmp	r0, #117	; 0x75                               
a0009364:	13500055 	cmpne	r0, #85	; 0x55                              
a0009368:	13a01000 	movne	r1, #0                                      
a000936c:	03a01001 	moveq	r1, #1                                      
      base = 10; sign = false;                                        
a0009370:	03a0900a 	moveq	r9, #10                                     
    if ( c == 'o' || c == 'O' ) {                                     
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
                c == 'd' || c == 'D' ) {                              
      base = 10; sign = true;                                         
    } else if ( c == 'u' || c == 'U' ) {                              
a0009374:	0affff67 	beq	a0009118 <vprintk+0xf0>                       
      base = 10; sign = false;                                        
    } else if ( c == 'x' || c == 'X' ) {                              
a0009378:	e3500078 	cmp	r0, #120	; 0x78                               
a000937c:	13500058 	cmpne	r0, #88	; 0x58                              
a0009380:	13a02000 	movne	r2, #0                                      
a0009384:	03a02001 	moveq	r2, #1                                      
      base = 16; sign = false;                                        
a0009388:	03a09010 	moveq	r9, #16                                     
a000938c:	01a02001 	moveq	r2, r1                                      
    } else if ( c == 'i' || c == 'I' ||                               
                c == 'd' || c == 'D' ) {                              
      base = 10; sign = true;                                         
    } else if ( c == 'u' || c == 'U' ) {                              
      base = 10; sign = false;                                        
    } else if ( c == 'x' || c == 'X' ) {                              
a0009390:	0affff60 	beq	a0009118 <vprintk+0xf0>                       
      base = 16; sign = false;                                        
    } else if ( c == 'p' ) {                                          
a0009394:	e3500070 	cmp	r0, #112	; 0x70                               
a0009398:	1affff9f 	bne	a000921c <vprintk+0x1f4>                      
      base = 16; sign = false; lflag = true;                          
a000939c:	e3a09010 	mov	r9, #16                                       
a00093a0:	eaffff5e 	b	a0009120 <vprintk+0xf8>                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
    BSP_output_char('-');                                             
a00093a4:	e5983000 	ldr	r3, [r8]                                      
a00093a8:	e3a0002d 	mov	r0, #45	; 0x2d                                
a00093ac:	e12fff33 	blx	r3                                            
    unsigned_num = (unsigned long) -num;                              
    if (maxwidth) maxwidth--;                                         
a00093b0:	e3560000 	cmp	r6, #0                                        
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
    BSP_output_char('-');                                             
    unsigned_num = (unsigned long) -num;                              
a00093b4:	e2677000 	rsb	r7, r7, #0                                    
    if (maxwidth) maxwidth--;                                         
a00093b8:	12466001 	subne	r6, r6, #1                                  
a00093bc:	eaffff5f 	b	a0009140 <vprintk+0x118>                        
                                                                      

a0016328 <write>: ) { ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd );
a0016328:	e59f30a8 	ldr	r3, [pc, #168]	; a00163d8 <write+0xb0>        <== NOT EXECUTED
ssize_t write(                                                        
  int         fd,                                                     
  const void *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
a001632c:	e92d4030 	push	{r4, r5, lr}                                 <== NOT EXECUTED
  ssize_t  rc;                                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0016330:	e593c000 	ldr	ip, [r3]                                      <== NOT EXECUTED
ssize_t write(                                                        
  int         fd,                                                     
  const void *buffer,                                                 
  size_t      count                                                   
)                                                                     
{                                                                     
a0016334:	e1a05001 	mov	r5, r1                                        <== NOT EXECUTED
  ssize_t  rc;                                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
a0016338:	e150000c 	cmp	r0, ip                                        <== NOT EXECUTED
a001633c:	2a00001b 	bcs	a00163b0 <write+0x88>                         <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a0016340:	e59fc094 	ldr	ip, [pc, #148]	; a00163dc <write+0xb4>        <== NOT EXECUTED
a0016344:	e3a04038 	mov	r4, #56	; 0x38                                <== NOT EXECUTED
a0016348:	e59cc000 	ldr	ip, [ip]                                      <== NOT EXECUTED
a001634c:	e024c490 	mla	r4, r0, r4, ip                                <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
a0016350:	e5940014 	ldr	r0, [r4, #20]                                 <== NOT EXECUTED
a0016354:	e3100c01 	tst	r0, #256	; 0x100                              <== NOT EXECUTED
a0016358:	0a000014 	beq	a00163b0 <write+0x88>                         <== NOT EXECUTED
  rtems_libio_check_buffer( buffer );                                 
a001635c:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a0016360:	0a000017 	beq	a00163c4 <write+0x9c>                         <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
a0016364:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a0016368:	0a00000e 	beq	a00163a8 <write+0x80>                         <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a001636c:	e3100004 	tst	r0, #4                                        <== NOT EXECUTED
a0016370:	0a000013 	beq	a00163c4 <write+0x9c>                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
  rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );      
a0016374:	e5943020 	ldr	r3, [r4, #32]                                 <== NOT EXECUTED
a0016378:	e1a00004 	mov	r0, r4                                        <== NOT EXECUTED
a001637c:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a0016380:	e12fff33 	blx	r3                                            <== NOT EXECUTED
                                                                      
  if ( rc > 0 )                                                       
a0016384:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a0016388:	da000007 	ble	a00163ac <write+0x84>                         <== NOT EXECUTED
    iop->offset += rc;                                                
a001638c:	e284300c 	add	r3, r4, #12                                   <== NOT EXECUTED
a0016390:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a0016394:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
a0016398:	e0a33fc0 	adc	r3, r3, r0, asr #31                           <== NOT EXECUTED
a001639c:	e584200c 	str	r2, [r4, #12]                                 <== NOT EXECUTED
a00163a0:	e5843010 	str	r3, [r4, #16]                                 <== NOT EXECUTED
a00163a4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
a00163a8:	e1a00002 	mov	r0, r2                                        <== NOT EXECUTED
                                                                      
  if ( rc > 0 )                                                       
    iop->offset += rc;                                                
                                                                      
  return rc;                                                          
}                                                                     
a00163ac:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  ssize_t  rc;                                                        
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
a00163b0:	ebffeb4a 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00163b4:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a00163b8:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00163bc:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00163c0:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
  rtems_libio_check_buffer( buffer );                                 
  rtems_libio_check_count( count );                                   
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a00163c4:	ebffeb45 	bl	a00110e0 <__errno>                             <== NOT EXECUTED
a00163c8:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a00163cc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a00163d0:	e3e00000 	mvn	r0, #0                                        <== NOT EXECUTED
a00163d4:	e8bd8030 	pop	{r4, r5, pc}                                  <== NOT EXECUTED
                                                                      

a000a88c <writev>: int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd );
a000a88c:	e59f315c 	ldr	r3, [pc, #348]	; a000a9f0 <writev+0x164>      <== NOT EXECUTED
ssize_t writev(                                                       
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
a000a890:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}                     <== NOT EXECUTED
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  ssize_t        old;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
a000a894:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
ssize_t writev(                                                       
  int                 fd,                                             
  const struct iovec *iov,                                            
  int                 iovcnt                                          
)                                                                     
{                                                                     
a000a898:	e1a05002 	mov	r5, r2                                        <== NOT EXECUTED
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  ssize_t        old;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
a000a89c:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000a8a0:	2a00004b 	bcs	a000a9d4 <writev+0x148>                       <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
a000a8a4:	e59f3148 	ldr	r3, [pc, #328]	; a000a9f4 <writev+0x168>      <== NOT EXECUTED
a000a8a8:	e3a08038 	mov	r8, #56	; 0x38                                <== NOT EXECUTED
a000a8ac:	e5933000 	ldr	r3, [r3]                                      <== NOT EXECUTED
a000a8b0:	e0283890 	mla	r8, r0, r8, r3                                <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
a000a8b4:	e5983014 	ldr	r3, [r8, #20]                                 <== NOT EXECUTED
a000a8b8:	e3130c01 	tst	r3, #256	; 0x100                              <== NOT EXECUTED
a000a8bc:	0a000044 	beq	a000a9d4 <writev+0x148>                       <== NOT EXECUTED
  rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );            
a000a8c0:	e3130004 	tst	r3, #4                                        <== NOT EXECUTED
a000a8c4:	0a00003c 	beq	a000a9bc <writev+0x130>                       <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
a000a8c8:	e3510000 	cmp	r1, #0                                        <== NOT EXECUTED
a000a8cc:	0a00003a 	beq	a000a9bc <writev+0x130>                       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
a000a8d0:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000a8d4:	da000038 	ble	a000a9bc <writev+0x130>                       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
a000a8d8:	e3520b01 	cmp	r2, #1024	; 0x400                             <== NOT EXECUTED
a000a8dc:	ca000036 	bgt	a000a9bc <writev+0x130>                       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
a000a8e0:	e1a04001 	mov	r4, r1                                        <== NOT EXECUTED
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
a000a8e4:	e3a0cc7f 	mov	ip, #32512	; 0x7f00                           <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
a000a8e8:	e3a01000 	mov	r1, #0                                        <== NOT EXECUTED
a000a8ec:	e1a02004 	mov	r2, r4                                        <== NOT EXECUTED
a000a8f0:	e3a06001 	mov	r6, #1                                        <== NOT EXECUTED
a000a8f4:	e1a07001 	mov	r7, r1                                        <== NOT EXECUTED
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
a000a8f8:	e28cc0ff 	add	ip, ip, #255	; 0xff                           <== NOT EXECUTED
a000a8fc:	ea000000 	b	a000a904 <writev+0x78>                          <== NOT EXECUTED
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
a000a900:	e1a07003 	mov	r7, r3                                        <== NOT EXECUTED
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
a000a904:	e5923000 	ldr	r3, [r2]                                      <== NOT EXECUTED
   *  this loop does that check as well and sets "all-zero" appropriately.
   *  The variable "all_zero" is used as an early exit point before   
   *  entering the write loop.                                        
   */                                                                 
  all_zeros = true;                                                   
  for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {                    
a000a908:	e2811001 	add	r1, r1, #1                                    <== NOT EXECUTED
                                                                      
    /*                                                                
     *  iov[v].iov_len cannot be less than 0 because size_t is unsigned.
     *  So we only check for zero.                                    
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
a000a90c:	e3530000 	cmp	r3, #0                                        <== NOT EXECUTED
a000a910:	0a000029 	beq	a000a9bc <writev+0x130>                       <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
a000a914:	e5920004 	ldr	r0, [r2, #4]                                  <== NOT EXECUTED
   *  this loop does that check as well and sets "all-zero" appropriately.
   *  The variable "all_zero" is used as an early exit point before   
   *  entering the write loop.                                        
   */                                                                 
  all_zeros = true;                                                   
  for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {                    
a000a918:	e2822008 	add	r2, r2, #8                                    <== NOT EXECUTED
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
a000a91c:	e0873000 	add	r3, r7, r0                                    <== NOT EXECUTED
     */                                                               
    if ( iov[v].iov_base == 0 )                                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
a000a920:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a924:	13a06000 	movne	r6, #0                                      <== NOT EXECUTED
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
a000a928:	e1570003 	cmp	r7, r3                                        <== NOT EXECUTED
a000a92c:	d153000c 	cmple	r3, ip                                      <== NOT EXECUTED
a000a930:	d3a07000 	movle	r7, #0                                      <== NOT EXECUTED
a000a934:	c3a07001 	movgt	r7, #1                                      <== NOT EXECUTED
a000a938:	ca00001f 	bgt	a000a9bc <writev+0x130>                       <== NOT EXECUTED
   *  this loop does that check as well and sets "all-zero" appropriately.
   *  The variable "all_zero" is used as an early exit point before   
   *  entering the write loop.                                        
   */                                                                 
  all_zeros = true;                                                   
  for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {                    
a000a93c:	e1550001 	cmp	r5, r1                                        <== NOT EXECUTED
a000a940:	caffffee 	bgt	a000a900 <writev+0x74>                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * A writev with all zeros is supposed to have no effect per OpenGroup.
   */                                                                 
  if ( all_zeros == true ) {                                          
a000a944:	e3560000 	cmp	r6, #0                                        <== NOT EXECUTED
a000a948:	1a00001f 	bne	a000a9cc <writev+0x140>                       <== NOT EXECUTED
a000a94c:	e1a07006 	mov	r7, r6                                        <== NOT EXECUTED
a000a950:	ea000003 	b	a000a964 <writev+0xd8>                          <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
a000a954:	e2866001 	add	r6, r6, #1                                    <== NOT EXECUTED
a000a958:	e1550006 	cmp	r5, r6                                        <== NOT EXECUTED
a000a95c:	e2844008 	add	r4, r4, #8                                    <== NOT EXECUTED
a000a960:	da000019 	ble	a000a9cc <writev+0x140>                       <== NOT EXECUTED
    /* all zero lengths has no effect */                              
    if ( iov[v].iov_len == 0 )                                        
a000a964:	e5942004 	ldr	r2, [r4, #4]                                  <== NOT EXECUTED
a000a968:	e3520000 	cmp	r2, #0                                        <== NOT EXECUTED
a000a96c:	0afffff8 	beq	a000a954 <writev+0xc8>                        <== NOT EXECUTED
      continue;                                                       
                                                                      
    bytes = (*iop->pathinfo.handlers->write_h)(                       
a000a970:	e5983020 	ldr	r3, [r8, #32]                                 <== NOT EXECUTED
a000a974:	e5941000 	ldr	r1, [r4]                                      <== NOT EXECUTED
a000a978:	e1a00008 	mov	r0, r8                                        <== NOT EXECUTED
a000a97c:	e593300c 	ldr	r3, [r3, #12]                                 <== NOT EXECUTED
a000a980:	e12fff33 	blx	r3                                            <== NOT EXECUTED
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
a000a984:	e3500000 	cmp	r0, #0                                        <== NOT EXECUTED
a000a988:	ba000016 	blt	a000a9e8 <writev+0x15c>                       <== NOT EXECUTED
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
a000a98c:	0a000006 	beq	a000a9ac <writev+0x120>                       <== NOT EXECUTED
      iop->offset += bytes;                                           
a000a990:	e288300c 	add	r3, r8, #12                                   <== NOT EXECUTED
a000a994:	e893000c 	ldm	r3, {r2, r3}                                  <== NOT EXECUTED
a000a998:	e0922000 	adds	r2, r2, r0                                   <== NOT EXECUTED
a000a99c:	e0a33fc0 	adc	r3, r3, r0, asr #31                           <== NOT EXECUTED
a000a9a0:	e588200c 	str	r2, [r8, #12]                                 <== NOT EXECUTED
a000a9a4:	e5883010 	str	r3, [r8, #16]                                 <== NOT EXECUTED
      total       += bytes;                                           
a000a9a8:	e0877000 	add	r7, r7, r0                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
a000a9ac:	e5943004 	ldr	r3, [r4, #4]                                  <== NOT EXECUTED
a000a9b0:	e1500003 	cmp	r0, r3                                        <== NOT EXECUTED
a000a9b4:	0affffe6 	beq	a000a954 <writev+0xc8>                        <== NOT EXECUTED
a000a9b8:	ea000003 	b	a000a9cc <writev+0x140>                         <== NOT EXECUTED
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
      rtems_set_errno_and_return_minus_one( EINVAL );                 
a000a9bc:	eb001dfb 	bl	a00121b0 <__errno>                             <== NOT EXECUTED
a000a9c0:	e3a03016 	mov	r3, #22                                       <== NOT EXECUTED
a000a9c4:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000a9c8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
a000a9cc:	e1a00007 	mov	r0, r7                                        <== NOT EXECUTED
a000a9d0:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                      <== NOT EXECUTED
  ssize_t        old;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open( iop );                                   
a000a9d4:	eb001df5 	bl	a00121b0 <__errno>                             <== NOT EXECUTED
a000a9d8:	e3a03009 	mov	r3, #9                                        <== NOT EXECUTED
a000a9dc:	e5803000 	str	r3, [r0]                                      <== NOT EXECUTED
a000a9e0:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a000a9e4:	eafffff8 	b	a000a9cc <writev+0x140>                         <== NOT EXECUTED
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
      return -1;                                                      
a000a9e8:	e3e07000 	mvn	r7, #0                                        <== NOT EXECUTED
a000a9ec:	eafffff6 	b	a000a9cc <writev+0x140>                         <== NOT EXECUTED